nhibernate-commit — CVS Commits

[Nhibernate-commit] nhibernate/src/Iesi.Collections .cvsignore,NONE,1.1 AssemblyInfo.cs,NONE,1.1 DictionarySet.cs,NONE,1.1 HashedSet.cs,NONE,1.1 HybridSet.cs,NONE,1.1 Iesi.Collections-1.1.csproj,NONE,1.1 Iesi.Collections.build,NONE,1.1 Iesi.Collections.license.txt,NONE,1.1 ImmutableSet.cs,NONE,1.1 ISet.cs,NONE,1.1 ListSet.cs,NONE,1.1 NamespaceDoc.cs,NONE,1.1 Set.cs,NONE,1.1 SortedSet.cs,NONE,1.1 SynchronizedSet.cs,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/Iesi.Collections
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv5237/src/Iesi.Collections

Added Files:
	.cvsignore AssemblyInfo.cs DictionarySet.cs HashedSet.cs 
	HybridSet.cs Iesi.Collections-1.1.csproj 
	Iesi.Collections.build Iesi.Collections.license.txt 
	ImmutableSet.cs ISet.cs ListSet.cs NamespaceDoc.cs Set.cs 
	SortedSet.cs SynchronizedSet.cs 
Log Message:
Added code for real implementation of ISet instead of the IDictionary hack
we currently use.

--- NEW FILE: SynchronizedSet.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Iesi.Collections-1.1.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{CEF80E5F-E838-4F27-9435-2E3630D5F9E0}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "Iesi.Collections"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "Iesi.Collections"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "true"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "true"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = "bin\Debug\"
                    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"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = "bin\Release\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
            </Settings>
            <References>
                <Reference
                    Name = "System"
                    AssemblyName = "System"
                    HintPath = "..\..\..\..\WINNT\Microsoft.NET\Framework\v1.0.3705\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "..\..\..\..\WINNT\Microsoft.NET\Framework\v1.0.3705\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "..\..\..\..\WINNT\Microsoft.NET\Framework\v1.0.3705\System.XML.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "DictionarySet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "HashedSet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "HybridSet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "Iesi.Collections.build"
                    BuildAction = "None"
                />
                <File
                    RelPath = "ImmutableSet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ISet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "ListSet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NamespaceDoc.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "Set.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "SortedSet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "SynchronizedSet.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: ISet.cs ---
using System;
using System.Collections;

namespace Iesi.Collections
{
	/// <summary>
	/// <p>A collection that contains no duplicate elements.  This interface models the mathematical
	/// <c>Set</c> abstraction.    
	/// The order of elements in a set is dependant on (a)the data-structure implementation, and 
	/// (b)the implementation of the various <c>Set</c> methods, and thus is not guaranteed.</p>
	/// 
	/// <p>None of the <c>Set</c> implementations in this library are guranteed to be thread-safe
	/// in any way unless wrapped in a <c>SynchronizedSet</c>.</p>
	/// 
	/// <p>The following table summarizes the binary operators that are supported by the <c>Set</c> class.</p>
	/// <list type="table">
	///		<listheader>
	///			<term>Operation</term>
	///			<term>Description</term>
	///			<term>Method</term>
	///		</listheader>
	///		<item>
	///			<term>Union (OR)</term>
	///			<term>Element included in result if it exists in either <c>A</c> OR <c>B</c>.</term>
	///			<term><c>Union()</c></term>
	///		</item>
	///		<item>
	///			<term>Intersection (AND)</term>
	///			<term>Element included in result if it exists in both <c>A</c> AND <c>B</c>.</term>
	///			<term><c>InterSect()</c></term>
	///		</item>
	///		<item>
	///			<term>Exclusive Or (XOR)</term>
	///			<term>Element included in result if it exists in one, but not both, of <c>A</c> and <c>B</c>.</term>
	///			<term><c>ExclusiveOr()</c></term>
	///		</item>
	///		<item>
	///			<term>Minus (n/a)</term>
	///			<term>Take all the elements in <c>A</c>.  Now, if any of them exist in <c>B</c>, remove
	///			them.  Note that unlike the other operators, <c>A - B</c> is not the same as <c>B - A</c>.</term>
	///			<term><c>Minus()</c></term>
	///		</item>
	/// </list>
	/// </summary>
	public interface ISet : ICollection, ICloneable
	{	/// <summary>
		/// Performs a "union" of the two sets, where all the elements
		/// in both sets are present.  That is, the element is included if it is in either <c>a</c> or <c>b</c>.
		/// Neither this set nor the input set are modified during the operation.  The return value
		/// is a <c>Clone()</c> of this set with the extra elements added in.
		/// </summary>
		/// <param name="a">A collection of elements.</param>
		/// <returns>A new <c>Set</c> containing the union of this <c>Set</c> with the specified collection.
		/// Neither of the input objects is modified by the union.</returns>
		ISet Union(ISet a);

		/// <summary>
		/// Performs an "intersection" of the two sets, where only the elements
		/// that are present in both sets remain.  That is, the element is included if it exists in
		/// both sets.  The <c>Intersect()</c> operation does not modify the input sets.  It returns
		/// a <c>Clone()</c> of this set with the appropriate elements removed.
		/// </summary>
		/// <param name="a">A set of elements.</param>
		/// <returns>The intersection of this set with <c>a</c>.</returns>
		ISet Intersect(ISet a);

		/// <summary>
		/// Performs a "minus" of set <c>b</c> from set <c>a</c>.  This returns a set of all
		/// the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
		/// The original sets are not modified during this operation.  The result set is a <c>Clone()</c>
		/// of this <c>Set</c> containing the elements from the operation.
		/// </summary>
		/// <param name="a">A set of elements.</param>
		/// <returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
		ISet Minus(ISet a);

		/// <summary>
		/// Performs an "exclusive-or" of the two sets, keeping only the elements that
		/// are in one of the sets, but not in both.  The original sets are not modified
		/// during this operation.  The result set is a <c>Clone()</c> of this set containing
		/// the elements from the exclusive-or operation.
		/// </summary>
		/// <param name="a">A set of elements.</param>
		/// <returns>A set containing the result of <c>a ^ b</c>.</returns>
		ISet ExclusiveOr(ISet a);

		/// <summary>
		/// Returns <c>true</c> if this set contains the specified element.
		/// </summary>
		/// <param name="o">The element to look for.</param>
		/// <returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
		bool Contains(object o);

		/// <summary>
		/// Returns <c>true</c> if the set contains all the elements in the specified collection.
		/// </summary>
		/// <param name="c">A collection of objects.</param>
		/// <returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
		bool ContainsAll(ICollection c);

		/// <summary>
		/// Returns <c>true</c> if this set contains no elements.
		/// </summary>
		bool IsEmpty{get;}

		/// <summary>
		/// Adds the specified element to this set if it is not already present.
		/// </summary>
		/// <param name="o">The object to add to the set.</param>
		/// <returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
		bool Add(object o);

		/// <summary>
		/// Adds all the elements in the specified collection to the set if they are not already present.
		/// </summary>
		/// <param name="c">A collection of objects to add to the set.</param>
		/// <returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
		bool AddAll(ICollection c);

		/// <summary>
		/// Removes the specified element from the set.
		/// </summary>
		/// <param name="o">The element to be removed.</param>
		/// <returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
		bool Remove(object o);

		/// <summary>
		/// Remove all the specified elements from this set, if they exist in this set.
		/// </summary>
		/// <param name="c">A collection of elements to remove.</param>
		/// <returns><c>true</c> if the set was modified as a result of this operation.</returns>
		bool RemoveAll(ICollection c);


		/// <summary>
		/// Retains only the elements in this set that are contained in the specified collection.
		/// </summary>
		/// <param name="c">Collection that defines the set of elements to be retained.</param>
		/// <returns><c>true</c> if this set changed as a result of this operation.</returns>
		bool RetainAll(ICollection c);

		/// <summary>
		/// Removes all objects from the set.
		/// </summary>
		void Clear();

	}
}

--- NEW FILE: NamespaceDoc.cs ---
using System;

namespace Iesi.Collections
{
	/// <summary>
	///		<p>
	///			The System.Collections namespace in the .NET Framework provides a number of collection 
	///			types that are extremely useful for manipulating data in memory. However, there is one 
	///			type of collection that is conspicuously missing from <c>System.Collections</c>: the 
	///			<c>Set</c>.
	///		</p>
	///		<p>
	///			A <c>Set</c> is a collection that contains no duplicate elements, and where the order of
	///			the elements may be arbitrary. It is loosely modelled after 
	///			the mathematical concept of a "set." This implementation is based on the Java <c>Set</c> 
	///			interface definition, so if you are also a Java programmer, this may seem familiar. 
	///			This library provides a number of "standard" <c>Set</c> operators that the Java library 
	///			neglected to include.
	///		</p>
	///		<p>
	///			<c>Sets</c> come in handy when an <c>Array</c> or a <c>List</c> won't quite fit the bill. 
	///			Arrays in .NET have a fixed length, making it tedious to add and remove elements. 
	///			Lists allow you add new objects easily, but you can have numerous duplicate 
	///			elements, which is undesirable for some types of problems. 
	///			Searching Arrays or Lists for elements is just plain slow for large data sets, 
	///			requiring a linear search. You could keep the array sorted and use a binary search, 
	///			but that is often more trouble than it is worth (especially since this library, 
	///			and the .NET Framework, provide better ways that are already written for you).
	///		</p>
	///		<p>
	///			With sets, adding elements, removing elements, and checking for the existence 
	///			of an element is fast and simple. You can mix and match the elements in different 
	///			sets using the supported mathematical set operators: union, intersection, 
	///			exclusive-or, and minus. 
	///		</p>
	///		<p>
	///			You will see some interesting side effects with different <c>Set</c> 
	///			implementations in this library, depending on the underlying search algorithm. 
	///			For example, if you choose a sort-based <c>Set</c>, the elements will come out 
	///			in sort order when you iterate using <c>foreach</c>. If you use a hash-based 
	///			<c>Set</c>, the elements will come out in no particular order, but checking 
	///			for inclusion will fastest when dealing with large data sets. If you use a 
	///			list-based <c>Set</c>, elements will come out in the order you put them in 
	///			when you iterate (although the effect of operators on element order in 
	///			<c>Set</c> instances is not well defined by design). Additionally, list-based 
	///			sets are fastest for very small data sets (up to about 10 elements), 
	///			but get slower very quickly as the number of contained elements increases. 
	///			To get the best of both worlds, the library provides a <c>Set</c> type that 
	///			uses lists for small data sets and switches to a hash-based algorithm when 
	///			the data set gets large enough to warrant it.
	///		</p>
	///		<p>
	///			The following sample program demonstrates some of the features of sets:
	///			<code>
	///using System;
	///using Iesi.Collections;
	///namespace RiverDemo
	///{    
	///	class Rivers
	///	{
	///		[STAThread]
	///		static void Main(string[] args)
	///		{
	///			//Use Arrays (which are ICollection objects) to quickly initialize.
	///			Set arizona   
	///				= new SortedSet(new string[] {"Colorado River"});
	///			Set california
	///				= new SortedSet(new string[] {"Colorado River", "Sacramento River"});
	///			Set colorado
	///				= new SortedSet(new string[] {"Arkansas River", "Colorado River", "Green River", "Rio Grande"});
	///			Set kansas
	///				= new SortedSet(new string[] {"Arkansas River", "Missouri River"});
	///			Set nevada
	///				= new SortedSet(new string[] {"Colorado River"});
	///			Set newMexico
	///				= new SortedSet(new string[] {"Rio Grande"});
	///			Set utah
	///				= new SortedSet(new string[] {"Colorado River", "Green River", "San Juan River"});
	///			//Rivers by region.
	///			Set southWest = colorado | newMexico | arizona | utah;
	///			Set midWest = kansas;
	///			Set west = california | nevada;
	///			//All rivers (at least for the demo).
	///			Set all = southWest | midWest | west;
	///			Print("All rivers:", all);
	///			Print("Rivers in the southwest:", southWest);
	///			Print("Rivers in the west:", west);
	///			Print("Rivers in the midwest:", midWest);
	///			Console.WriteLine();
	///
	///			//Use the '-' operator to subtract the rivers in Colorado from 
	///			//the set of all rivers.
	///			Print("Of all rivers, these don't pass through Colorado:", all - colorado);
	///
	///			//Use the '&amp;' operator to find rivers that are in Colorado AND in Utah.
	///			//A river must be present in both states, not just one.
	///			Print("Rivers common to both Colorado and Utah:", colorado &amp; utah);
	///
	///			//use the '^' operator to find rivers that are in Colorado OR Utah,
	///			//but not in both.
	///			Print("Rivers in Colorado and Utah that are not shared by both states:",
	///				colorado ^ utah);
	///
	///			//Use the '&amp;' operator to discover which rivers are present in Arizona, 
	///			// California,Colorado, Nevada, and Utah.  The river must be present in 
	///			// all states to be counted.
	///			Print("Rivers common to Arizona, California, Colorado, Nevada, and Utah:", 
	///				arizona &amp; california &amp; colorado &amp; nevada &amp; utah);
	///			//Just to prove to you that operators always return like types, let's do a
	///			//complex Set operation and look at the type of the result:
	///			Console.WriteLine("The type of this complex operation is: " + 
	///				((southWest ^ colorado &amp; california) | kansas).GetType().FullName);
	///		}
	///		private static void Print(string title, Set elements)
	///		{
	///			Console.WriteLine(title);
	///			foreach(object o in elements)
	///			{
	///				Console.WriteLine("\t" + o);
	///				Console.WriteLine();
	///			}    
	///		}
	///	}
	///			</code>
	///		</p>
	///		<p>
	///			Although there are other kinds of sets available in the library, the example uses 
	///			<c>SortedSet</c> throughout. This is nice for the example, since everything will 
	///			print neatly in alphabetical order. But you may be wondering what kind of <c>Set</c>
	///			is returned when you "union," "intersect," "exclusive-or," or "minus" two <c>Set</c>
	///			instances. The library always returns a <c>Set</c> that is the same type as 
	///			the <c>Set</c> on the left, unless the left operand is null, in which case it 
	///			returns the type of the <c>Set</c> on the right.
	///		</p>
	///		<p>
	///			Here is the output from running the example:
	///			<code>
	///All rivers:
	///Arkansas River
	///Colorado River
	///Green River
	///Missouri River
	///Rio Grande
	///Sacramento River
	///San Juan River
	///
	///Rivers in the southwest:
	///Arkansas River
	///Colorado River
	///Green River
	///Rio Grande
	///San Juan River
	///
	///Rivers in the west:
	///Colorado River
	///Sacramento River
	///
	///Rivers in the midwest:
	///Arkansas River
	///Missouri River
	///
	///Of all rivers, these don't pass through Colorado:
	///Missouri River
	///Sacramento River
	///San Juan River
	///
	///Rivers common to both Colorado and Utah:
	///Colorado River
	///Green River
	///
	///Rivers in Colorado and Utah that are not shared by both states:
	///Arkansas River
	///Rio Grande
	///San Juan River
	///
	///Rivers common to Arizona, California, Colorado, Nevada, and Utah:
	///Colorado River
	///
	///The type of this complex operation is: 
	///Iesi.Collections.SortedSet
	///Press any key to continue
	///			</code>
	///		</p> 
	/// </summary>
	internal sealed class NamespaceDoc
	{
	}
}

--- NEW FILE: ListSet.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ImmutableSet.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Set.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: AssemblyInfo.cs ---
using System.Reflection;
using System.Runtime.CompilerServices;

//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

[assembly: AssemblyTitleAttribute("Iesi.Collections for Microsoft .NET Framework 1.1")]
[assembly: AssemblyDescriptionAttribute("Enhanced Collections for .NET.  Code was published at http://www.codeproject.com/" +
"csharp/sets.asp")]
[assembly: AssemblyCompanyAttribute("nhibernate.sourceforge.net")]
[assembly: AssemblyProductAttribute("Iesi.Collections")]
[assembly: AssemblyCopyrightAttribute("Declaration of code in public domain can be found in comment by Jason Smith at ht" +
"tp://www.codeproject.com/csharp/sets.asp#xx703510xx.  Copyright © 2002-2004 by A" +
"idant Systems, Inc., and by Jason Smith.")]
[assembly: AssemblyVersionAttribute("1.0.0.1")]
[assembly: AssemblyInformationalVersionAttribute("1.0")]
[assembly: AssemblyFileVersionAttribute("1.0.0.1")]
[assembly: AssemblyKeyFileAttribute("..\\NHibernate.snk")]


--- NEW FILE: Iesi.Collections.build ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Iesi.Collections.license.txt ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: HashedSet.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: SortedSet.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: DictionarySet.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: .cvsignore ---
bin
obj
.#*
*.user
*.xsx
--- NEW FILE: HybridSet.cs ---
(This appears to be a binary file; contents omitted.)

[Nhibernate-commit] nhibernate/lib/net/1.1 Iesi.Collections.dll,NONE,1.1 Iesi.Collections.license.txt,NONE,1.1 Iesi.Collections.xml,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/lib/net/1.1
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv5237/lib/net/1.1

Added Files:
	Iesi.Collections.dll Iesi.Collections.license.txt 
	Iesi.Collections.xml 
Log Message:
Added code for real implementation of ISet instead of the IDictionary hack
we currently use.

--- NEW FILE: Iesi.Collections.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Iesi.Collections.xml ---
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Iesi.Collections</name>
    </assembly>
    <members>
        <member name="T:Iesi.Collections.DictionarySet">
            <summary>
            <p><c>DictionarySet</c> is an abstract class that supports the creation of new <c>Set</c>
            types where the underlying data store is an <c>IDictionary</c> instance.</p> 
             
            <p>You can use any object that implements the <c>IDictionary</c> interface to hold set data.
            You can define your own, or you can use one of the objects provided in the Framework.   
            The type of <c>IDictionary</c> you choose will affect both the performance and the behavior
            of the <c>Set</c> using it. </p>
            
            <p>To make a <c>Set</c> typed based on your own <c>IDictionary</c>, simply derive a
            new class with a constructor that takes no parameters.  Some <c>Set</c> implmentations
            cannot be defined with a default constructor.  If this is the case for your class, 
[...1050 lines suppressed...]
        </member>
        <member name="P:Iesi.Collections.SynchronizedSet.Count">
            <summary>
            The number of elements contained in this collection.
            </summary>
        </member>
        <member name="P:Iesi.Collections.SynchronizedSet.IsSynchronized">
            <summary>
            Returns <c>true</c>, indicating that this object is thread-safe.  The exception to this
            is enumeration, which is inherently not thread-safe.  Use the <c>SyncRoot</c> object to
            lock this object for the entire duration of the enumeration.
            </summary>
        </member>
        <member name="P:Iesi.Collections.SynchronizedSet.SyncRoot">
            <summary>
            Returns an object that can be used to synchronize the <c>Set</c> between threads.
            </summary>
        </member>
    </members>
</doc>

--- NEW FILE: Iesi.Collections.license.txt ---
(This appears to be a binary file; contents omitted.)

[Nhibernate-commit] nhibernate/src/Iesi.Collections - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/Iesi.Collections
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4028/Iesi.Collections

Log Message:
Directory /cvsroot/nhibernate/nhibernate/src/Iesi.Collections added to the repository

[Nhibernate-commit] nhibernate/src/NHibernate.Test FooBarTest.cs,1.71,1.72

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/NHibernate.Test
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13841

Modified Files:
	FooBarTest.cs 
Log Message:
added test to verify one-to-one was working with null on one end.

Index: FooBarTest.cs
===================================================================
RCS file: /cvsroot/nhibernate/nhibernate/src/NHibernate.Test/FooBarTest.cs,v
retrieving revision 1.71
retrieving revision 1.72
diff -C2 -d -r1.71 -r1.72
*** FooBarTest.cs	8 Nov 2004 02:55:39 -0000	1.71
--- FooBarTest.cs	17 Nov 2004 02:32:13 -0000	1.72
***************
*** 428,431 ****
--- 428,445 ----
  			s.Flush();
  			s.Close();
+ 
+ 			// check to see if Y can exist without a X
+ 			y = new Y();
+ 			s = sessions.OpenSession();
+ 			s.Save( y );
+ 			s.Flush();
+ 			s.Close();
+ 
+ 			s = sessions.OpenSession();
+ 			y = (Y)s.Load( typeof(Y), y.Id );
+ 			Assert.IsNull( y.X, "y does not need an X" );
+ 			s.Delete( y );
+ 			s.Flush();
+ 			s.Close()
  		}
  

[Nhibernate-commit] nhibernate/src/NHibernate.Test CriteriaTest.cs,1.6,1.7

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/NHibernate.Test
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27191

Modified Files:
	CriteriaTest.cs 
Log Message:
Added test to verify DateTime properties with Gt & Lt expressions
worked correctly.

Index: CriteriaTest.cs
===================================================================
RCS file: /cvsroot/nhibernate/nhibernate/src/NHibernate.Test/CriteriaTest.cs,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** CriteriaTest.cs	20 Sep 2004 17:45:58 -0000	1.6
--- CriteriaTest.cs	17 Nov 2004 01:02:14 -0000	1.7
***************
*** 67,70 ****
--- 67,112 ----
  			s2.Close();
  		}
+ 
+ 		[Test]
+ 		public void SimpleDateCriteria() 
+ 		{
+ 			Simple s1 = new Simple();
+ 			s1.Address = "blah";
+ 			s1.Count = 1;
+ 			s1.Date = new DateTime( 2004, 01, 01 );
+ 			
+ 			Simple s2 = new Simple();
+ 			s2.Address = "blah";
+ 			s2.Count = 2;
+ 			s2.Date = new DateTime( 2006, 01, 01 );
+ 
+ 			ISession s = sessions.OpenSession();
+ 			s.Save( s1, 1 );
+ 			s.Save( s2, 2 );
+ 			s.Flush();
+ 			s.Close();
+ 
+ 			s = sessions.OpenSession();
+ 			IList results = s.CreateCriteria( typeof(Simple) )
+ 				.Add( Expression.Expression.Gt( "Date", new DateTime( 2005, 01, 01 ) ) )
+ 				.AddOrder( Expression.Order.Asc( "Date" ) )
+ 				.List();
+ 
+ 			Assert.AreEqual( 1, results.Count, "one gt from 2005" );
+ 			Simple simple = (Simple)results[0];
+ 			Assert.IsTrue( simple.Date > new DateTime( 2005, 01, 01), "should have returned dates after 2005" );
+ 		
+ 			results = s.CreateCriteria( typeof(Simple) )
+ 				.Add( Expression.Expression.Lt( "Date", new DateTime( 2005, 01, 01 ) ) )
+ 				.AddOrder( Expression.Order.Asc( "Date" ) )
+ 				.List();
+ 			
+ 			Assert.AreEqual( 1, results.Count, "one lt than 2005" );
+ 			simple = (Simple)results[0];
+ 			Assert.IsTrue( simple.Date < new DateTime( 2005, 01, 01 ), "should be less than 2005" );
+ 
+ 			s.Delete( "from Simple" );
+ 			s.Close();
+ 		}
  	}
  }

[Nhibernate-commit] nhibernate/src/NHibernate.Test/ExpressionTest SimpleExpressionFixture.cs,1.2,1.3

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/NHibernate.Test/ExpressionTest
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27191/ExpressionTest

Modified Files:
	SimpleExpressionFixture.cs 
Log Message:
Added test to verify DateTime properties with Gt & Lt expressions
worked correctly.

Index: SimpleExpressionFixture.cs
===================================================================
RCS file: /cvsroot/nhibernate/nhibernate/src/NHibernate.Test/ExpressionTest/SimpleExpressionFixture.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** SimpleExpressionFixture.cs	19 Jul 2004 03:25:25 -0000	1.2
--- SimpleExpressionFixture.cs	17 Nov 2004 01:02:15 -0000	1.3
***************
*** 1,3 ****
--- 1,4 ----
  using System;
+ using System.Collections;
  using System.Data;
  using System.Text;
***************
*** 52,55 ****
--- 53,82 ----
  		}
  
+ 		[Test]
+ 		public void SimpleDateExpression() 
+ 		{
+ 			ISession session = factory.OpenSession();
+ 			
+ 			NExpression.Expression andExpression = NExpression.Expression.Ge( "Date", DateTime.Now );
+ 
+ 			SqlString sqlString = andExpression.ToSqlString( factoryImpl, typeof(Simple), "simple_alias" );
+ 
+ 			string expectedSql = "simple_alias.date_ >= :simple_alias.date_";
+ 			Parameter[] expectedParams = new Parameter[1];
+ 			
+ 			Parameter firstAndParam = new Parameter();
+ 			firstAndParam.SqlType = new SqlTypes.DateTimeSqlType();
+ 			firstAndParam.TableAlias = "simple_alias";
+ 			firstAndParam.Name = "date_";
+ 
+ 			expectedParams[0] = firstAndParam;
+ 
+ 			CompareSqlStrings(sqlString, expectedSql, expectedParams);
+ 
+ 			session.Close();
+ 		}
+ 
+ 		
+ 
  
  	}

[Nhibernate-commit] nhibernate/src/NHibernate.Tasks Hbm2NetTask.cs,1.1,1.2

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/NHibernate.Tasks
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv18889

Modified Files:
	Hbm2NetTask.cs 
Log Message:
NH-149: Quoting of args

Index: Hbm2NetTask.cs
===================================================================
RCS file: /cvsroot/nhibernate/nhibernate/src/NHibernate.Tasks/Hbm2NetTask.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** Hbm2NetTask.cs	25 Jul 2004 11:41:34 -0000	1.1
--- Hbm2NetTask.cs	16 Nov 2004 04:21:39 -0000	1.2
***************
*** 61,73 ****
  			if(_output != null)
  			{
! 				sb.Append("--output=" + _output + " ");
  			}
  			if(_config != null)
  			{
! 				sb.Append("--config=" + _config + " ");
  			}
  			foreach(string filename in _set.FileNames)
  			{
! 				sb.Append(filename + " ");
  			}
  			_args = sb.ToString();
--- 61,73 ----
  			if(_output != null)
  			{
! 				sb.Append("--output=\"" + _output + "\" ");
  			}
  			if(_config != null)
  			{
! 				sb.Append("--config=\"" + _config + "\" ");
  			}
  			foreach(string filename in _set.FileNames)
  			{
! 				sb.Append("\"" + filename + "\" ");
  			}
  			_args = sb.ToString();

[Nhibernate-commit] nhibernate/src/NHibernate.Test/NHSpecificTest AvalonProxyFixture.cs,1.1.2.3,1.1.2.4

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/nhibernate/src/NHibernate.Test/NHSpecificTest
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv5747/NHibernate.Test/NHSpecificTest

Modified Files:
      Tag: alpha_avalon-proxy
	AvalonProxyFixture.cs 
Log Message:
Trying to find problem with FooBarTest.PersistCollections by duplicating
scenarios that could be causing it.  I believe it might be internal to 
Castle.DynamicProxy but need to find a way to duplicate it with a less 
complex scenario than the current test.

Index: AvalonProxyFixture.cs
===================================================================
RCS file: /cvsroot/nhibernate/nhibernate/src/NHibernate.Test/NHSpecificTest/Attic/AvalonProxyFixture.cs,v
retrieving revision 1.1.2.3
retrieving revision 1.1.2.4
diff -C2 -d -r1.1.2.3 -r1.1.2.4
*** AvalonProxyFixture.cs	11 Nov 2004 22:37:21 -0000	1.1.2.3
--- AvalonProxyFixture.cs	15 Nov 2004 05:26:21 -0000	1.1.2.4
***************
*** 70,73 ****
--- 70,94 ----
  		}
  
+ 		[Test]
+ 		public void SerializeNotFoundProxy() 
+ 		{
+ 			ISession s = sessions.OpenSession();
+ 			// this does not actually exists in db
+ 			AvalonProxy notThere = (AvalonProxy)s.Load( typeof(AvalonProxyImpl), 5 ); 
+ 			Assert.AreEqual( 5, notThere.Id );
+ 			s.Disconnect();
+ 				
+ 			// serialize and then deserialize the session.
+ 			System.IO.Stream stream = new System.IO.MemoryStream();
+ 			System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter( );
+ 			formatter.Serialize(stream, s);
+ 			stream.Position = 0;
+ 			s = (ISession)formatter.Deserialize(stream);
+ 			stream.Close();
+ 
+ 			Assert.IsNotNull( s.Load( typeof(AvalonProxyImpl), 5 ), "should be proxy - even though it doesn't exists in db" );			
+ 			s.Close();
+ 		}
+ 
  	}
  }

[Nhibernate-commit] NHibernateContrib/src/Nullables.Tests .cvsignore,NONE,1.1 App.config,NONE,1.1 AssemblyInfo.cs,NONE,1.1 BasicTests.cs,NONE,1.1 Nullables.Tests-1.1.csproj,NONE,1.1 Nullables.Tests.build,NONE,1.1 Nullables.Tests.nunit,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables.Tests
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/src/Nullables.Tests

Added Files:
	.cvsignore App.config AssemblyInfo.cs BasicTests.cs 
	Nullables.Tests-1.1.csproj Nullables.Tests.build 
	Nullables.Tests.nunit 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: .cvsignore ---
bin
obj
.#*
*.user
*.xsx
--- NEW FILE: Nullables.Tests.nunit ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: App.config ---
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
   	 <configSections>
	        <section name="nhibernate" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
	        <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
	</configSections>
	
	<nhibernate>
		
		<add 
			key="hibernate.connection.provider"          
			value="NHibernate.Connection.DriverConnectionProvider" 
		/>

		<add
			key="hibernate.connection.isolation"
			value="ReadCommitted"
		/>
		
		<add 
			key="hibernate.dialect"                      
			value="NHibernate.Dialect.MsSql2000Dialect" 
		/>
		<add 
			key="hibernate.connection.driver_class"          
			value="NHibernate.Driver.SqlClientDriver" 
		/>
		<add 
			key="hibernate.connection.connection_string" 
			value="Server=localhost;initial catalog=nhibernate;Integrated Security=SSPI" 
		/>

	</nhibernate>

	<!-- This section contains the log4net configuration settings -->
	<log4net debug="true">

		<!-- Define some output appenders -->	

		<appender name="rollingFile" type="log4net.Appender.RollingFileAppender,log4net" >
			
			<param name="File" value="log.txt" />
			<param name="AppendToFile" value="true" />
			<param name="RollingStyle" value="Date" />
			<param name="DatePattern" value="yyyy.MM.dd" />
			<param name="StaticLogFileName" value="true" />

			<layout type="log4net.Layout.PatternLayout,log4net">
				<param name="ConversionPattern" value="%d [%t] %-5p %c [%x] &lt;%X{auth}&gt; - %m%n" />
			</layout>
		</appender>

		<!-- Setup the root category, add the appenders and set the default priority -->
		
		<root>
			<priority value="ALL" />
			<appender-ref ref="rollingFile" />
		</root>
		
		
		
	</log4net>
	

</configuration>



--- NEW FILE: BasicTests.cs ---
using System;
using NUnit.Framework;
using Nullables;

namespace Nullables.Tests
{
	[TestFixture]
	public class BasicTests
	{
		public BasicTests()
		{
		}

		[Test]
		public void BasicTestInt32()
		{
			NullableInt32 v1 = 32; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(32)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 32);
			Assert.IsFalse(v1.Equals(NullableInt32.Default));
			Assert.IsTrue(v1.Equals(new NullableInt32(32))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 32); 
			Assert.IsFalse(v1 == 33); 
			Assert.IsFalse(v1 == NullableInt32.Default);
			Assert.IsTrue(v1 == new NullableInt32(32));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableInt32.Default);
			v1 = NullableInt32.Default;
			Assert.IsTrue(v1 == NullableInt32.Default);

			NullableInt32 v2 = NullableInt32.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(12));
			Assert.IsTrue(v2.Equals(NullableInt32.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
			Assert.IsTrue( v2==null );
		}

		[Test]
		public void BasicTestInt64()
		{
			NullableInt64 v1 = 46816684; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(46816684)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 46816684);
			Assert.IsFalse(v1.Equals(NullableInt64.Default));
			Assert.IsTrue(v1.Equals(new NullableInt64(46816684))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 46816684); 
			Assert.IsFalse(v1 == 448494894); 
			Assert.IsFalse(v1 == NullableInt64.Default);
			Assert.IsTrue(v1 == new NullableInt64(46816684));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableInt64.Default);
			v1 = NullableInt64.Default;
			Assert.IsTrue(v1 == NullableInt64.Default);

			NullableInt64 v2 = NullableInt64.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(4484));
			Assert.IsTrue(v2.Equals(NullableInt64.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}

		[Test]
		public void BasicTestInt16()
		{
			NullableInt16 v1 = 32; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(32)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 32);
			Assert.IsFalse(v1.Equals(NullableInt16.Default));
			Assert.IsTrue(v1.Equals(new NullableInt16(32))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 32); 
			Assert.IsFalse(v1 == 33); 
			Assert.IsFalse(v1 == NullableInt16.Default);
			Assert.IsTrue(v1 == new NullableInt16(32));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableInt16.Default);
			v1 = NullableInt16.Default;
			Assert.IsTrue(v1 == NullableInt16.Default);

			NullableInt16 v2 = NullableInt16.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(12));
			Assert.IsTrue(v2.Equals(NullableInt16.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}


		[Test]
		public void BasicTestByte()
		{
			NullableByte v1 = 32; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(32)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 32);
			Assert.IsFalse(v1.Equals(NullableByte.Default));
			Assert.IsTrue(v1.Equals(new NullableByte(32))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 32); 
			Assert.IsFalse(v1 == 33); 
			Assert.IsFalse(v1 == NullableByte.Default);
			Assert.IsTrue(v1 == new NullableByte(32));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableByte.Default);
			v1 = NullableByte.Default;
			Assert.IsTrue(v1 == NullableByte.Default);

			NullableByte v2 = NullableByte.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(12));
			Assert.IsTrue(v2.Equals(NullableByte.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}

		
		[Test]
		public void BasicTestGuid()
		{
			NullableGuid v1 = new Guid("00000000-0000-0000-0000-000000000005"); //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(new Guid("00000000-0000-0000-0000-000000000005"))); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == new Guid("00000000-0000-0000-0000-000000000005"));
			Assert.IsFalse(v1.Equals(NullableGuid.Default));
			Assert.IsTrue(v1.Equals(new NullableGuid(new Guid("00000000-0000-0000-0000-000000000005")))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == new Guid("00000000-0000-0000-0000-000000000005")); 
			Assert.IsFalse(v1 == new Guid("00000000-0000-0000-0000-000000000008")); 
			Assert.IsFalse(v1 == NullableGuid.Default);
			Assert.IsTrue(v1 == new NullableGuid(new Guid("00000000-0000-0000-0000-000000000005")));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableGuid.Default);
			v1 = NullableGuid.Default;
			Assert.IsTrue(v1 == NullableGuid.Default);

			NullableGuid v2 = NullableGuid.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(new Guid("00000000-0000-0000-0000-000000000002")));
			Assert.IsTrue(v2.Equals(NullableGuid.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}

		[Test]
		public void BasicTestSingle()
		{
			NullableSingle v1 = 32; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(32)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 32);
			Assert.IsFalse(v1.Equals(NullableSingle.Default));
			Assert.IsTrue(v1.Equals(new NullableSingle(32))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 32); 
			Assert.IsFalse(v1 == 33); 
			Assert.IsFalse(v1 == NullableSingle.Default);
			Assert.IsTrue(v1 == new NullableSingle(32));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableSingle.Default);
			v1 = NullableSingle.Default;
			Assert.IsTrue(v1 == NullableSingle.Default);

			NullableSingle v2 = NullableSingle.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(12));
			Assert.IsTrue(v2.Equals(NullableSingle.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}

		[Test]
		public void BasicTestDouble()
		{
			NullableDouble v1 = 32; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(32)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 32);
			Assert.IsFalse(v1.Equals(NullableDouble.Default));
			Assert.IsTrue(v1.Equals(new NullableDouble(32))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 32); 
			Assert.IsFalse(v1 == 33); 
			Assert.IsFalse(v1 == NullableDouble.Default);
			Assert.IsTrue(v1 == new NullableDouble(32));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableDouble.Default);
			v1 = NullableDouble.Default;
			Assert.IsTrue(v1 == NullableDouble.Default);

			NullableDouble v2 = NullableDouble.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(12));
			Assert.IsTrue(v2.Equals(NullableDouble.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}

		[Test]
		public void BasicTestDateTime()
		{
			NullableDateTime v1 = new DateTime(1979, 11, 8); //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(new DateTime(1979, 11, 8))); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == new DateTime(1979, 11, 8));
			Assert.IsFalse(v1.Equals(NullableDateTime.Default));
			Assert.IsTrue(v1.Equals(new NullableDateTime(new DateTime(1979, 11, 8)))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == new DateTime(1979, 11, 8)); 
			Assert.IsFalse(v1 == new DateTime(1980, 10, 9)); 
			Assert.IsFalse(v1 == NullableDateTime.Default);
			Assert.IsTrue(v1 == new NullableDateTime(new DateTime(1979, 11, 8)));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableDateTime.Default);
			v1 = NullableDateTime.Default;
			Assert.IsTrue(v1 == NullableDateTime.Default);

			NullableDateTime v2 = NullableDateTime.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(new DateTime(2004, 12, 25)));
			Assert.IsTrue(v2.Equals(NullableDateTime.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}

		[Test]
		public void BasicTestDecimal()
		{
			NullableDecimal v1 = 4.99m; //should take an int literal

			Assert.IsTrue(v1.HasValue); //should have a value;
			Assert.IsTrue(v1.Equals(4.99m)); //implicit casting should make this result in true.
			Assert.IsTrue(v1.Value == 4.99m);
			Assert.IsFalse(v1.Equals(NullableDecimal.Default));
			Assert.IsTrue(v1.Equals(new NullableDecimal(4.99m))); //should == a new instance with the same inner value.

			//same thing, but with == instead of .Equals()
			Assert.IsTrue(v1 == 4.99m); 
			Assert.IsFalse(v1 == 5.01m); 
			Assert.IsFalse(v1 == NullableDecimal.Default);
			Assert.IsTrue(v1 == new NullableDecimal(4.99m));

			//now null v1.
			v1 = DBNull.Value;
			Assert.IsTrue(v1 == NullableDecimal.Default);
			v1 = NullableDecimal.Default;
			Assert.IsTrue(v1 == NullableDecimal.Default);

			NullableDecimal v2 = NullableDecimal.Default; //should start as "null"

			Assert.IsFalse(v2.HasValue);
			Assert.IsFalse(v2.Equals(4.01m));
			Assert.IsTrue(v2.Equals(NullableDecimal.Default));
			Assert.IsTrue(v2.Equals(DBNull.Value));
		}
	}
}

--- NEW FILE: Nullables.Tests.build ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Nullables.Tests-1.1.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{2D3FBB15-830A-4A9E-82D7-A0712B7330E1}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "Nullables.Tests"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = 'copy /y "$(ProjectDir)App.config" "$(TargetPath).config"'
                PostBuildEvent = ""
                RootNamespace = "Nullables.Tests"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = "bin\Debug\"
                    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"
                    NoStdLib = "false"
                    NoWarn = ""
                    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.1.4322\System.dll"
                />
                <Reference
                    Name = "Nullables"
                    Project = "{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}"
                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "..\..\..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "..\..\..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                />
                <Reference
                    Name = "Nullables.NHibernate"
                    Project = "{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}"
                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
                />
                <Reference
                    Name = "log4net"
                    AssemblyName = "log4net"
                    HintPath = "..\..\lib\net\1.1\log4net.dll"
                />
                <Reference
                    Name = "NHibernate"
                    AssemblyName = "NHibernate"
                    HintPath = "..\..\lib\net\1.1\NHibernate.dll"
                />
                <Reference
                    Name = "nunit.framework"
                    AssemblyName = "nunit.framework"
                    HintPath = "..\..\lib\net\1.1\nunit.framework.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "App.config"
                    BuildAction = "None"
                />
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "BasicTests.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "Nullables.Tests.build"
                    BuildAction = "None"
                />
                <File
                    RelPath = "Nullables.Tests.nunit"
                    BuildAction = "None"
                />
                <File
                    RelPath = "NHibernate\NullablesClass.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NHibernate\NullablesClass.hbm.xml"
                    BuildAction = "EmbeddedResource"
                />
                <File
                    RelPath = "NHibernate\NullablesFixture.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NHibernate\TestCase.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: AssemblyInfo.cs ---
using System.Reflection;
using System.Runtime.CompilerServices;

//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

[assembly: AssemblyTitleAttribute("Nullables.Tests for Microsoft .NET Framework 1.1")]
[assembly: AssemblyDescriptionAttribute("The Unit Tests for Nullables and their NHibernate Types.")]
[assembly: AssemblyCompanyAttribute("nhibernate.sourceforge.net")]
[assembly: AssemblyProductAttribute("Nullables.Tests")]
[assembly: AssemblyCopyrightAttribute("Licensed under LGPL.")]
[assembly: AssemblyVersionAttribute("0.4.0.0")]
[assembly: AssemblyInformationalVersionAttribute("0.4")]
[assembly: AssemblyFileVersionAttribute("0.4.0.0")]
[assembly: AssemblyDelaySignAttribute(false)]

[Nhibernate-commit] NHibernateContrib/src/Nullables/TypeConverters NullableBooleanConverter.cs,NONE,1.1 NullableByteConverter.cs,NONE,1.1 NullableDateTimeConverter.cs,NONE,1.1 NullableDecimalConverter.cs,NONE,1.1 NullableDoubleConverter.cs,NONE,1.1 NullableGuidConverter.cs,NONE,1.1 NullableInt16Converter.cs,NONE,1.1 NullableInt32Converter.cs,NONE,1.1 NullableInt64Converter.cs,NONE,1.1 NullableSingleConverter.cs,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables/TypeConverters
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/src/Nullables/TypeConverters

Added Files:
	NullableBooleanConverter.cs NullableByteConverter.cs 
	NullableDateTimeConverter.cs NullableDecimalConverter.cs 
	NullableDoubleConverter.cs NullableGuidConverter.cs 
	NullableInt16Converter.cs NullableInt32Converter.cs 
	NullableInt64Converter.cs NullableSingleConverter.cs 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: NullableGuidConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableGuidConverter : TypeConverter
	{
		public NullableGuidConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableGuid.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableGuid.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Guid));
				
				Guid newValue = (Guid)converter.ConvertFromString(context, culture, stringValue);

				return new NullableGuid(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableGuid)
			{
				NullableGuid nullable = (NullableGuid)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Guid) } ;
				ConstructorInfo constructor = typeof(NullableGuid).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableGuid((Guid)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableGuid), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableDateTimeConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableDateTimeConverter : TypeConverter
	{
		public NullableDateTimeConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableDateTime.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableDateTime.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(DateTime));
				
				DateTime newValue = (DateTime)converter.ConvertFromString(context, culture, stringValue);

				return new NullableDateTime(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableDateTime)
			{
				NullableDateTime nullable = (NullableDateTime)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(DateTime) } ;
				ConstructorInfo constructor = typeof(NullableDateTime).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableDateTime((DateTime)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableDateTime), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableDecimalConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableDecimalConverter : TypeConverter
	{
		public NullableDecimalConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableDecimal.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableDecimal.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Decimal));
				
				Decimal newValue = (Decimal)converter.ConvertFromString(context, culture, stringValue);

				return new NullableDecimal(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableDecimal)
			{
				NullableDecimal nullable = (NullableDecimal)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Decimal) } ;
				ConstructorInfo constructor = typeof(NullableDecimal).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableDecimal((Decimal)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableDecimal), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableSingleConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableSingleConverter : TypeConverter
	{
		public NullableSingleConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableSingle.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableSingle.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Single));
				
				Single newValue = (Single)converter.ConvertFromString(context, culture, stringValue);

				return new NullableSingle(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableSingle)
			{
				NullableSingle nullable = (NullableSingle)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Single) } ;
				ConstructorInfo constructor = typeof(NullableSingle).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableSingle((Single)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableSingle), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableBooleanConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableBooleanConverter : TypeConverter
	{
		public NullableBooleanConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableBoolean.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableBoolean.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Boolean));
				
				Boolean newValue = (Boolean)converter.ConvertFromString(context, culture, stringValue);

				return new NullableBoolean(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableBoolean)
			{
				NullableBoolean nullable = (NullableBoolean)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Boolean) } ;
				ConstructorInfo constructor = typeof(NullableBoolean).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableBoolean((Boolean)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableBoolean), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableInt64Converter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableInt64Converter : TypeConverter
	{
		public NullableInt64Converter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableInt64.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableInt64.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Int64));
				
				Int64 newValue = (Int64)converter.ConvertFromString(context, culture, stringValue);

				return new NullableInt64(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableInt64)
			{
				NullableInt64 nullable = (NullableInt64)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Int64) } ;
				ConstructorInfo constructor = typeof(NullableInt64).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableInt64((Int64)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableInt64), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableInt32Converter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableInt32Converter : TypeConverter
	{
		public NullableInt32Converter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableInt32.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableInt32.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Int32));
				
				Int32 newValue = (Int32)converter.ConvertFromString(context, culture, stringValue);

				return new NullableInt32(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableInt32)
			{
				NullableInt32 nullable = (NullableInt32)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Int32) } ;
				ConstructorInfo constructor = typeof(NullableInt32).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableInt32((Int32)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableInt32), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableByteConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableByteConverter : TypeConverter
	{
		public NullableByteConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableByte.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableByte.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Byte));
				
				Byte newValue = (Byte)converter.ConvertFromString(context, culture, stringValue);

				return new NullableByte(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableByte)
			{
				NullableByte nullable = (NullableByte)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Byte) } ;
				ConstructorInfo constructor = typeof(NullableByte).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableByte((Byte)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableByte), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableDoubleConverter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableDoubleConverter : TypeConverter
	{
		public NullableDoubleConverter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableDouble.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableDouble.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Double));
				
				Double newValue = (Double)converter.ConvertFromString(context, culture, stringValue);

				return new NullableDouble(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableDouble)
			{
				NullableDouble nullable = (NullableDouble)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Double) } ;
				ConstructorInfo constructor = typeof(NullableDouble).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableDouble((Double)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableDouble), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

--- NEW FILE: NullableInt16Converter.cs ---
using System;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;

namespace Nullables.TypeConverters
{
	public class NullableInt16Converter : TypeConverter
	{
		public NullableInt16Converter()
		{
		}

		public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
		{
			Console.WriteLine("CanConvertFrom? " + sourceType.ToString());
			if (sourceType == typeof(string))
				return true;
			else
				return base.CanConvertFrom (context, sourceType);
		}

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			Console.WriteLine("CanConvertTo? " + destinationType.ToString());
			if (destinationType == typeof(InstanceDescriptor))
				return true;
			else
				return base.CanConvertTo (context, destinationType);
		}

		public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
		{
			if (value == null)
			{
				return NullableInt16.Default;
			}
			if (value is string)
			{
				string stringValue = ((string)value).Trim();

				if (stringValue == string.Empty)
					return NullableInt16.Default;

				//get underlying types converter
				TypeConverter converter = TypeDescriptor.GetConverter(typeof(Int16));
				
				Int16 newValue = (Int16)converter.ConvertFromString(context, culture, stringValue);

				return new NullableInt16(newValue);
			}
			else
			{
				return base.ConvertFrom (context, culture, value);
			}
		}

		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
		{
			if (destinationType == typeof(InstanceDescriptor) && value is NullableInt16)
			{
				NullableInt16 nullable = (NullableInt16)value;
				
				Type[] constructorArgTypes = new Type[1] { typeof(Int16) } ;
				ConstructorInfo constructor = typeof(NullableInt16).GetConstructor(constructorArgTypes);

				if (constructor != null)
				{
					object[] constructorArgValues = new object[1] { nullable.Value } ;
					return new InstanceDescriptor(constructor, constructorArgValues);
				}
			}

			return base.ConvertTo (context, culture, value, destinationType);
		}

		public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues)
		{
			return new NullableInt16((Int16)propertyValues["Value"]);
		}

		public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(typeof(NullableInt16), attributes);
		}

		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	}
}

[Nhibernate-commit] NHibernateContrib/src/Nullables.NHibernate .cvsignore,NONE,1.1 AssemblyInfo.cs,NONE,1.1 NullableBooleanType.cs,NONE,1.1 NullableByteType.cs,NONE,1.1 NullableDateTimeType.cs,NONE,1.1 NullableDecimalType.cs,NONE,1.1 NullableDoubleType.cs,NONE,1.1 NullableGuidType.cs,NONE,1.1 NullableInt16Type.cs,NONE,1.1 NullableInt32Type.cs,NONE,1.1 NullableInt64Type.cs,NONE,1.1 Nullables.NHibernate-1.1.csproj,NONE,1.1 Nullables.NHibernate.build,NONE,1.1 NullableSingleType.cs,NONE,1.1 NullablesTypes.cs,NONE,1.1 NullableTypesType.cs,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables.NHibernate
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/src/Nullables.NHibernate

Added Files:
	.cvsignore AssemblyInfo.cs NullableBooleanType.cs 
	NullableByteType.cs NullableDateTimeType.cs 
	NullableDecimalType.cs NullableDoubleType.cs 
	NullableGuidType.cs NullableInt16Type.cs NullableInt32Type.cs 
	NullableInt64Type.cs Nullables.NHibernate-1.1.csproj 
	Nullables.NHibernate.build NullableSingleType.cs 
	NullablesTypes.cs NullableTypesType.cs 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: NullableInt64Type.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableInt64Type : NullableTypesType
	{
		public NullableInt64Type() : base(new Int64SqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableInt64 xTyped = (NullableInt64)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableInt64.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableInt64"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableInt64); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableInt64 has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value )
			{
				return NullableInt64.Default;
			}
			else
			{
				return new NullableInt64((Int64)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableInt64 has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value )
			{
				return NullableInt64.Default;
			}
			else
			{
				return new NullableInt64((Int64)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableInt64 nullableValue = (NullableInt64)value;

			if( nullableValue.HasValue )
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: NullableByteType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableByteType : NullableTypesType
	{

		public NullableByteType() : base(new ByteSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableByte xTyped = (NullableByte)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableByte.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableByte"; }
		} 		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableByte); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableByte has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value ) 
			{
				return NullableByte.Default;
			}
			else 
			{
				return new NullableByte((Byte)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableByte has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value ) 
			{
				return NullableByte.Default;
			}
			else 
			{
				return new NullableByte((Byte)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableByte nullableValue = (NullableByte)value;
			
			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		}
	}
}
--- NEW FILE: NullableTypesType.cs ---
using System;

using NHibernate;
using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	/// <summary>
	/// Abstract type used for implementing types from the NullableTypes library.
	/// </summary>
	public abstract class NullableTypesType : NullableType
	{
		private static readonly log4net.ILog log = log4net.LogManager.GetLogger( typeof(NullableTypesType) ); 		

		public NullableTypesType(SqlType type) : base(type)
		{
		}

		public override object NullSafeGet(System.Data.IDataReader rs, string name)
		{
			int index = rs.GetOrdinal(name);

			if( rs.IsDBNull(index) ) 
			{
				if ( log.IsDebugEnabled ) 
				{
					log.Debug("returning null as column: " + name);
				}

				return NullValue; //this value is determined by the subclass.
			}
			else 
			{		
				object val = null;
				try 
				{
					val = Get(rs, index);
				}
				catch(System.InvalidCastException ice) 
				{
					throw new ADOException(
						"Could not cast the value in field " + name + " to the Type " + this.GetType().Name + 
						".  Please check to make sure that the mapping is correct and that your DataProvider supports this Data Type.", ice);
				}

				if ( log.IsDebugEnabled ) 
				{
					log.Debug("returning '" + ToXML(val) + "' as column: " + name);
				}

				return val;
			}
		}

		public abstract object NullValue{ get; }
	}
}

--- NEW FILE: NullableDoubleType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableDoubleType : NullableTypesType
	{
		public NullableDoubleType() : base(new DoubleSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableDouble xTyped = (NullableDouble)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableDouble.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableDouble"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableDouble); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableDouble has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value ) 
			{
				return NullableDouble.Default;
			}
			else 
			{
				return new NullableDouble((Double)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableDouble has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value )
			{
				return NullableDouble.Default;
			}
			else 
			{
				return new NullableDouble((Double)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableDouble nullableValue = (NullableDouble)value;

			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: NullableInt32Type.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableInt32Type : NullableTypesType
	{
		public NullableInt32Type() : base(new Int32SqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableInt32 xTyped = (NullableInt32)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableInt32.Default; }
		}
		
		public override bool HasNiceEquals
		{
			get { return true; }
		}
		
		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableInt32"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableInt32); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableInt32 has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value )
			{
				return NullableInt32.Default;
			}
			else 
			{
				return new NullableInt32((Int32)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableInt32 has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value ) 
			{
				return NullableInt32.Default;
			}
			else 
			{
				return new NullableInt32((Int32)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableInt32 nullableValue = (NullableInt32)value;

			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: NullableDecimalType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableDecimalType : NullableTypesType
	{

		public NullableDecimalType() : base(new DecimalSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableDecimal xTyped = (NullableDecimal)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableDecimal.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableDecimal"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableDecimal); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableDecimal has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value ) 
			{
				return NullableDecimal.Default;
			}
			else 
			{
				return new NullableDecimal((Decimal)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableDecimal has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value ) 
			{
				return NullableDecimal.Default;
			}
			else 
			{
				return new NullableDecimal((Decimal)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{

			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableDecimal nullableValue = (NullableDecimal)value;

			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: NullableInt16Type.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableInt16Type : NullableTypesType
	{
		public NullableInt16Type() : base(new Int16SqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableInt16 xTyped = (NullableInt16)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableInt16.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableInt16"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableInt16); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableInt16 has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value ) 
			{
				return NullableInt16.Default;
			}
			else 
			{
				return new NullableInt16((Int16)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableInt16 has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value ) 
			{
				return NullableInt16.Default;
			}
			else 
			{
				return new NullableInt16((Int16)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableInt16 nullableValue = (NullableInt16)value;

			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: NullableDateTimeType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableDateTimeType : NullableTypesType
	{
		public NullableDateTimeType() : base(new DateTimeSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableDateTime xTyped = (NullableDateTime)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableDateTime.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableDateTime"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableDateTime); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableDateTime has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value ) 
			{
				return NullableDateTime.Default;
			}
			else 
			{
				return new NullableDateTime((DateTime)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableDateTime has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value ) 
			{
				return NullableDateTime.Default;
			}
			else 
			{
				return new NullableDateTime((DateTime)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];

			NullableDateTime nullableValue = (NullableDateTime)value;

			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: NullableSingleType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableSingleType : NullableTypesType
	{
		public NullableSingleType() : base(new SingleSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableSingle xTyped = (NullableSingle)x;
			
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableSingle.Default; }
		}

		public override bool HasNiceEquals
		{
			get
			{
				//the results from .Equals on NullalbeTypes don't suite our use of them (we want 2 nulls to be equal)
				return true; 
			}
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableSingle"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableSingle); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableSingle has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value )
			{
				return NullableSingle.Default;
			}
			else 
			{
				return new NullableSingle((Single)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableSingle has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value )
			{
				return NullableSingle.Default;
			}
			else
			{
				return new NullableSingle((Single)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableSingle nullableValue = (NullableSingle)value;

			if( nullableValue.HasValue )
			{
				parameter.Value = nullableValue.Value;
			}
			else
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: Nullables.NHibernate-1.1.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "Nullables.NHibernate"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "Nullables.NHibernate"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = "bin\Debug\"
                    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"
                    NoStdLib = "false"
                    NoWarn = ""
                    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.1.4322\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "..\..\..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "..\..\..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                />
                <Reference
                    Name = "Nullables"
                    Project = "{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}"
                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
                />
                <Reference
                    Name = "log4net"
                    AssemblyName = "log4net"
                    HintPath = "..\..\lib\net\1.1\log4net.dll"
                />
                <Reference
                    Name = "NHibernate"
                    AssemblyName = "NHibernate"
                    HintPath = "..\..\lib\net\1.1\NHibernate.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableBooleanType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableByteType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableDateTimeType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableDecimalType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableDoubleType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableGuidType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableInt16Type.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableInt32Type.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableInt64Type.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "Nullables.NHibernate.build"
                    BuildAction = "None"
                />
                <File
                    RelPath = "NullableSingleType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullablesTypes.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableTypesType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: NullablesTypes.cs ---
using System;

using NHibernate.Type;

namespace Nullables.NHibernate
{
	/// <summary>
	/// Summary description for NullablesTypes.
	/// </summary>
	public sealed class NullablesTypes
	{
		/// <summary>
		/// Nullables.NHibernate.NullableBoolean type
		/// </summary>
		public static readonly NullableType NullableBoolean = new NullableBooleanType();
	
		/// <summary>
		/// Nullables.NHibernate.NullableByte type
		/// </summary>
		public static readonly NullableType NullableByte = new NullableByteType();
	
		/// <summary>
		/// Nullables.NHibernate.NullableDouble type
		/// </summary>
		public static readonly NullableType NullableDouble = new NullableDoubleType();
	
		/// <summary>
		/// Nullables.NHibernate.NullableInt16 type
		/// </summary>
		public static readonly NullableType NullableInt16 = new NullableInt16Type();
	
		/// <summary>
		/// Nullables.NHibernate.NullableInt32 type
		/// </summary>
		public static readonly NullableType NullableInt32 = new NullableInt32Type();
	
		/// <summary>
		/// Nullables.NHibernate.NullableInt64 type
		/// </summary>
		public static readonly NullableType NullableInt64 = new NullableInt64Type();
	
		/// <summary>
		/// Nullables.NHibernate.NullableDecimal type
		/// </summary>
		public static readonly NullableType NullableDecimal = new NullableDecimalType();
	
		/// <summary>
		/// Nullables.NHibernate.NullableDateTime type
		/// </summary>
		public static readonly NullableType NullableDateTime = new NullableDateTimeType();
	
		/// <summary>
		/// Nullables.NHibernate.NullableSingle type
		/// </summary>
		public static readonly NullableType NullableSingle = new NullableSingleType();
	
		/// <summary>
		/// Nullables.NHibernate.NullableGuid type
		/// </summary>
		public static readonly NullableType NullableGuid = new NullableGuidType();
	}
}

--- NEW FILE: Nullables.NHibernate.build ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: AssemblyInfo.cs ---
using System.Reflection;
using System.Runtime.CompilerServices;

//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

[assembly: AssemblyTitleAttribute("Nullables.NHibernate for Microsoft .NET Framework 1.1")]
[assembly: AssemblyDescriptionAttribute("The NHibernate Types for the Nullables.")]
[assembly: AssemblyCompanyAttribute("nhibernate.sourceforge.net")]
[assembly: AssemblyProductAttribute("Nullables.NHibernate")]
[assembly: AssemblyCopyrightAttribute("Licensed under LGPL.")]
[assembly: AssemblyVersionAttribute("0.4.0.0")]
[assembly: AssemblyInformationalVersionAttribute("0.4")]
[assembly: AssemblyFileVersionAttribute("0.4.0.0")]
[assembly: AssemblyDelaySignAttribute(false)]


--- NEW FILE: NullableBooleanType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableBooleanType : NullableTypesType
	{

		public NullableBooleanType() : base(new BooleanSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableBoolean xTyped = (NullableBoolean)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableBoolean.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; } 
		}

		public override string Name
		{
			get { return "NullableBoolean"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableBoolean); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableBoolean has a method/operator/contructor that will take an object.
			object value = rs[index];
			if( value==DBNull.Value ) 
			{
				return NullableBoolean.Default;
			}
			else 
			{
				return new NullableBoolean((Boolean)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableBoolean has a method/operator/contructor that will take an object.
			object value = rs[name];
			if( value==DBNull.Value )
			{
				return NullableBoolean.Default;
			}
			else
			{
				return new NullableBoolean((Boolean)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableBoolean nullableValue = (NullableBoolean)value;
			if( nullableValue.HasValue )
			{
				parameter.Value = nullableValue.Value;
			}
			else
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

--- NEW FILE: .cvsignore ---
bin
obj
.#*
*.user
*.xsx
--- NEW FILE: NullableGuidType.cs ---
using System;

using NHibernate.Type;
using NHibernate.SqlTypes;

using Nullables;

namespace Nullables.NHibernate
{
	public class NullableGuidType : NullableTypesType
	{
		public NullableGuidType() : base(new GuidSqlType())
		{
		}

		public override bool Equals(object x, object y)
		{
			//get boxed values.
			NullableGuid xTyped = (NullableGuid)x;
			return xTyped.Equals(y);
		}

		public override object NullValue
		{
			get { return NullableGuid.Default; }
		}

		public override bool HasNiceEquals
		{
			get { return true; }
		}

		public override bool IsMutable
		{
			get { return true; }
		}

		public override string Name
		{
			get { return "NullableGuid"; }
		}

		public override System.Type ReturnedClass
		{
			get { return typeof(Nullables.NullableGuid); }
		}

		public override object DeepCopyNotNull(object val)
		{
			return val;
		}

		public override object Get(System.Data.IDataReader rs, int index)
		{
			//TODO: perhaps NullableGuid has a method/operator/contructor that will take an object.
			object value = rs[index];

			if( value==DBNull.Value ) 
			{
				return NullableGuid.Default;
			}
			else 
			{
				return new NullableGuid((Guid)value);
			}
		}

		public override object Get(System.Data.IDataReader rs, string name)
		{
			//TODO: perhaps NullableGuid has a method/operator/contructor that will take an object.
			object value = rs[name];

			if( value==DBNull.Value ) 
			{
				return NullableGuid.Default;
			}
			else 
			{
				return new NullableGuid((Guid)value);
			}
		}

		public override void Set(System.Data.IDbCommand cmd, object value, int index)
		{
			System.Data.IDataParameter parameter = (System.Data.IDataParameter)cmd.Parameters[index];
			NullableGuid nullableValue = (NullableGuid)value;

			if( nullableValue.HasValue ) 
			{
				parameter.Value = nullableValue.Value;
			}
			else 
			{
				parameter.Value = DBNull.Value;
			}
		}

		public override string ToXML(object val)
		{
			return val.ToString();
		} 
	}
}

[Nhibernate-commit] NHibernateContrib/src/Nullables .cvsignore,NONE,1.1 AssemblyInfo.cs,NONE,1.1 INullableType.cs,NONE,1.1 NullableBoolean.cs,NONE,1.1 NullableByte.cs,NONE,1.1 NullableDateTime.cs,NONE,1.1 NullableDecimal.cs,NONE,1.1 NullableDouble.cs,NONE,1.1 NullableGuid.cs,NONE,1.1 NullableInt16.cs,NONE,1.1 NullableInt32.cs,NONE,1.1 NullableInt64.cs,NONE,1.1 Nullables-1.1.csproj,NONE,1.1 Nullables.build,NONE,1.1 NullableSingle.cs,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/src/Nullables

Added Files:
	.cvsignore AssemblyInfo.cs INullableType.cs NullableBoolean.cs 
	NullableByte.cs NullableDateTime.cs NullableDecimal.cs 
	NullableDouble.cs NullableGuid.cs NullableInt16.cs 
	NullableInt32.cs NullableInt64.cs Nullables-1.1.csproj 
	Nullables.build NullableSingle.cs 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: .cvsignore ---
bin
obj
.#*
*.user
*.xsx
--- NEW FILE: NullableInt16.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableInt16Converter)), Serializable()]
	public struct NullableInt16 : INullableType
	{
		public static readonly NullableInt16 Default = new NullableInt16();

		Int16 _value;
		bool hasValue;

		#region Constructors

		public NullableInt16(Int16 value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullableType Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Int16 Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Int16(NullableInt16 nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableInt16(Int16 value)
		{
			return new NullableInt16(value);
		}

		public static implicit operator NullableInt16(DBNull value)
		{
			return NullableInt16.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableInt16)
				return Equals((NullableInt16)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableInt16 x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableInt16 x, NullableInt16 y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableInt16 x, NullableInt16 y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableInt16 x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableInt16 x, NullableInt16 y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableInt16 x, object y)
		{
			return !x.Equals(y);
		}

		public static NullableInt32 operator +(NullableInt16 x, NullableInt16 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value + y.Value);
		}

		public static NullableInt32 operator -(NullableInt16 x, NullableInt16 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value - y.Value);
		}

		public static NullableInt32 operator *(NullableInt16 x, NullableInt16 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value * y.Value);
		}

		public static NullableInt32 operator /(NullableInt16 x, NullableInt16 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value / y.Value);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: NullableDateTime.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableDateTimeConverter)), Serializable()]
	public struct NullableDateTime : INullableType
	{
		public static readonly NullableDateTime Default = new NullableDateTime();

		DateTime _value;
		bool hasValue;

		#region Constructors

		public NullableDateTime(DateTime value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public DateTime Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator DateTime(NullableDateTime nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableDateTime(DateTime value)
		{
			return new NullableDateTime(value);
		}

		public static implicit operator NullableDateTime(DBNull value)
		{
			return NullableDateTime.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableDateTime)
				return Equals((NullableDateTime)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableDateTime x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableDateTime x, NullableDateTime y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableDateTime x, NullableDateTime y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableDateTime x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableDateTime x, NullableDateTime y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableDateTime x, object y)
		{
			return !x.Equals(y);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}

		//TODO: Operators for DateTime (?)
	}
}

--- NEW FILE: NullableByte.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableByteConverter)), Serializable()]
	public struct NullableByte : INullableType
	{
		public static readonly NullableByte Default = new NullableByte();

		Byte _value;
		bool hasValue;

		#region Constructors

		public NullableByte(Byte value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Byte Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Byte(NullableByte nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableByte(Byte value)
		{
			return new NullableByte(value);
		}

		public static implicit operator NullableByte(DBNull value)
		{
			return NullableByte.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableByte)
				return Equals((NullableByte)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableByte x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableByte x, NullableByte y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableByte x, NullableByte y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableByte x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableByte x, NullableByte y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableByte x, object y)
		{
			return !x.Equals(y);
		}

		public static NullableInt32 operator +(NullableByte x, NullableByte y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value + y.Value);
		}

		public static NullableInt32 operator -(NullableByte x, NullableByte y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value - y.Value);
		}

		public static NullableInt32 operator *(NullableByte x, NullableByte y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value * y.Value);
		}

		public static NullableInt32 operator /(NullableByte x, NullableByte y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value / y.Value);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: INullableType.cs ---
using System;

namespace Nullables
{
	public interface INullableType
	{
		object Value { get; }
		bool HasValue { get; }
	}
}

--- NEW FILE: NullableDouble.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableDoubleConverter)), Serializable()]
	public struct NullableDouble : INullableType
	{
		public static readonly NullableDouble Default = new NullableDouble();

		Double _value;
		bool hasValue;

		#region Constructors

		public NullableDouble(Double value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Double Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Double(NullableDouble nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableDouble(Double value)
		{
			return new NullableDouble(value);
		}

		public static implicit operator NullableDouble(DBNull value)
		{
			return NullableDouble.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableDouble)
				return Equals((NullableDouble)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableDouble x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableDouble x, NullableDouble y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableDouble x, NullableDouble y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableDouble x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableDouble x, NullableDouble y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableDouble x, object y)
		{
			return !x.Equals(y);
		}

		public static NullableDouble operator +(NullableDouble x, NullableDouble y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDouble.Default;

			return new NullableDouble(x.Value + y.Value);
		}

		public static NullableDouble operator -(NullableDouble x, NullableDouble y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDouble.Default;

			return new NullableDouble(x.Value - y.Value);
		}

		public static NullableDouble operator *(NullableDouble x, NullableDouble y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDouble.Default;

			return new NullableDouble(x.Value * y.Value);
		}

		public static NullableDouble operator /(NullableDouble x, NullableDouble y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDouble.Default;

			return new NullableDouble(x.Value / y.Value);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: Nullables.build ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: AssemblyInfo.cs ---
using System.Reflection;
using System.Runtime.CompilerServices;

//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

[assembly: AssemblyTitleAttribute("Nullables for Microsoft .NET Framework 1.1")]
[assembly: AssemblyDescriptionAttribute("A library of Nullable Primitive Types to serve as a bridge to .net-2.0.")]
[assembly: AssemblyCompanyAttribute("nhibernate.sourceforge.net")]
[assembly: AssemblyProductAttribute("Nullables")]
[assembly: AssemblyCopyrightAttribute("Licensed under LGPL.")]
[assembly: AssemblyVersionAttribute("0.4.0.0")]
[assembly: AssemblyInformationalVersionAttribute("0.4")]
[assembly: AssemblyFileVersionAttribute("0.4.0.0")]


--- NEW FILE: NullableSingle.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableSingleConverter)), Serializable()]
	public struct NullableSingle : INullableType
	{
		public static readonly NullableSingle Default = new NullableSingle();

		Single _value;
		bool hasValue;

		#region Constructors

		public NullableSingle(Single value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Single Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Single(NullableSingle nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableSingle(Single value)
		{
			return new NullableSingle(value);
		}

		public static implicit operator NullableSingle(DBNull value)
		{
			return NullableSingle.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableSingle)
				return Equals((NullableSingle)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableSingle x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableSingle x, NullableSingle y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableSingle x, NullableSingle y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableSingle x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableSingle x, NullableSingle y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableSingle x, object y)
		{
			return !x.Equals(y);
		}

		public static NullableSingle operator +(NullableSingle x, NullableSingle y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableSingle.Default;

			return new NullableSingle(x.Value + y.Value);
		}

		public static NullableSingle operator -(NullableSingle x, NullableSingle y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableSingle.Default;

			return new NullableSingle(x.Value - y.Value);
		}

		public static NullableSingle operator *(NullableSingle x, NullableSingle y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableSingle.Default;

			return new NullableSingle(x.Value * y.Value);
		}

		public static NullableSingle operator /(NullableSingle x, NullableSingle y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableSingle.Default;

			return new NullableSingle(x.Value / y.Value);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: NullableDecimal.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableDecimalConverter)), Serializable()]
	public struct NullableDecimal : INullableType
	{
		public static readonly NullableDecimal Default = new NullableDecimal();

		Decimal _value;
		bool hasValue;

		#region Constructors

		public NullableDecimal(Decimal value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Decimal Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Decimal(NullableDecimal nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableDecimal(Decimal value)
		{
			return new NullableDecimal(value);
		}

		public static implicit operator NullableDecimal(DBNull value)
		{
			return NullableDecimal.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableDecimal)
				return Equals((NullableDecimal)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableDecimal x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableDecimal x, NullableDecimal y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableDecimal x, NullableDecimal y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableDecimal x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableDecimal x, NullableDecimal y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableDecimal x, object y)
		{
			return !x.Equals(y);
		}

		public static NullableDecimal operator +(NullableDecimal x, NullableDecimal y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDecimal.Default;

			return new NullableDecimal(x.Value + y.Value);
		}

		public static NullableDecimal operator -(NullableDecimal x, NullableDecimal y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDecimal.Default;

			return new NullableDecimal(x.Value - y.Value);
		}

		public static NullableDecimal operator *(NullableDecimal x, NullableDecimal y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDecimal.Default;

			return new NullableDecimal(x.Value * y.Value);
		}

		public static NullableDecimal operator /(NullableDecimal x, NullableDecimal y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableDecimal.Default;

			return new NullableDecimal(x.Value / y.Value);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: NullableGuid.cs ---
using System;
using System.Runtime.Serialization;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableGuidConverter)), Serializable()]
	public struct NullableGuid : INullableType
	{
		public static readonly NullableGuid Default = new NullableGuid();

		Guid _value;
		bool hasValue;

		#region Constructors

		public NullableGuid(Guid value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Guid Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Guid(NullableGuid nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableGuid(Guid value)
		{
			return new NullableGuid(value);
		}

		public static implicit operator NullableGuid(DBNull value)
		{
			return NullableGuid.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableGuid)
				return Equals((NullableGuid)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableGuid x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableGuid x, NullableGuid y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableGuid x, NullableGuid y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableGuid x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableGuid x, NullableGuid y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableGuid x, object y)
		{
			return !x.Equals(y);
		}

		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: Nullables-1.1.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "Nullables"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "Nullables"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = "bin\Debug\"
                    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"
                    NoStdLib = "false"
                    NoWarn = ""
                    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.1.4322\System.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "INullableType.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableBoolean.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableByte.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableDateTime.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableDecimal.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableDouble.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableGuid.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableInt16.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableInt32.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "NullableInt64.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "Nullables.build"
                    BuildAction = "None"
                />
                <File
                    RelPath = "NullableSingle.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableBooleanConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableByteConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableDateTimeConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableDecimalConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableDoubleConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableGuidConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableInt16Converter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableInt32Converter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableInt64Converter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "TypeConverters\NullableSingleConverter.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: NullableInt32.cs ---
using System;
using System.Runtime.Serialization;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableInt32Converter)), Serializable()]
	public struct NullableInt32 : INullableType
	{
		public static readonly NullableInt32 Default = new NullableInt32();

		Int32 _value;
		bool hasValue;

		#region Constructors

		public NullableInt32(Int32 value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Int32 Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Int32(NullableInt32 nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableInt32(Int32 value)
		{
			return new NullableInt32(value);
		}

		public static implicit operator NullableInt32(DBNull value)
		{
			return NullableInt32.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableInt32)
				return Equals((NullableInt32)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableInt32 x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableInt32 x, NullableInt32 y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableInt32 x, NullableInt32 y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableInt32 x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableInt32 x, NullableInt32 y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableInt32 x, object y)
		{
			return !x.Equals(y);
		}

		public static NullableInt32 operator +(NullableInt32 x, NullableInt32 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value + y.Value);
		}

		public static NullableInt32 operator -(NullableInt32 x, NullableInt32 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value - y.Value);
		}

		public static NullableInt32 operator *(NullableInt32 x, NullableInt32 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value * y.Value);
		}

		public static NullableInt32 operator /(NullableInt32 x, NullableInt32 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt32.Default;

			return new NullableInt32(x.Value / y.Value);
		}

		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: NullableInt64.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableInt64Converter)), Serializable()]
	public struct NullableInt64 : INullableType
	{
		public static readonly NullableInt64 Default = new NullableInt64();

		Int64 _value;
		bool hasValue;

		#region Constructors

		public NullableInt64(Int64 value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Int64 Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Int64(NullableInt64 nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableInt64(Int64 value)
		{
			return new NullableInt64(value);
		}

		public static implicit operator NullableInt64(DBNull value)
		{
			return NullableInt64.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableInt64)
				return Equals((NullableInt64)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableInt64 x)
		{
			return Equals(this, x);
		}

		public static bool operator ==(NullableInt64 x, NullableInt64 y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableInt64 x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableInt64 x, NullableInt64 y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableInt64 x, object y)
		{
			return !x.Equals(y);
		}

		public static bool Equals(NullableInt64 x, NullableInt64 y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static NullableInt64 operator +(NullableInt64 x, NullableInt64 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt64.Default;

			return new NullableInt64(x.Value + y.Value);
		}

		public static NullableInt64 operator -(NullableInt64 x, NullableInt64 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt64.Default;

			return new NullableInt64(x.Value - y.Value);
		}

		public static NullableInt64 operator *(NullableInt64 x, NullableInt64 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt64.Default;

			return new NullableInt64(x.Value * y.Value);
		}

		public static NullableInt64 operator /(NullableInt64 x, NullableInt64 y)
		{
			if (!x.HasValue || !y.HasValue) //one or both are null
				return NullableInt64.Default;

			return new NullableInt64(x.Value / y.Value);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}
	}
}

--- NEW FILE: NullableBoolean.cs ---
using System;

namespace Nullables
{
	[System.ComponentModel.TypeConverter(typeof(Nullables.TypeConverters.NullableBooleanConverter)), Serializable()]
	public struct NullableBoolean : INullableType
	{
		public static readonly NullableBoolean Default = new NullableBoolean();

		Boolean _value;
		bool hasValue;

		#region Constructors

		public NullableBoolean(Boolean value)
		{
			_value = value;
			hasValue = true;
		}

		#endregion

		#region INullable Members

		object INullableType.Value
		{
			get { return Value; }
		}

		public bool HasValue
		{
			get { return hasValue; }
		}

		#endregion

		public Boolean Value
		{
			get { return _value; }
		}

		#region Casts

		public static explicit operator Boolean(NullableBoolean nullable)
		{
			if (!nullable.HasValue)
				throw new NullReferenceException();

			return nullable.Value;
		}

		public static implicit operator NullableBoolean(Boolean value)
		{
			return new NullableBoolean(value);
		}

		public static implicit operator NullableBoolean(DBNull value)
		{
			return NullableBoolean.Default;
		}

		#endregion

		public override string ToString()
		{
			if (HasValue)
				return Value.ToString();
			else
				return string.Empty;
		}

		public override bool Equals(object obj)
		{
			if (obj is DBNull && !HasValue)
				return true;
			else if (obj is NullableBoolean)
				return Equals((NullableBoolean)obj);
			else
				return false; //if this is reached, it is either some other type, or DBnull is compared with this and we have a Value.
		}

		public bool Equals(NullableBoolean x)
		{
			return Equals(this, x);
		}

		public static bool Equals(NullableBoolean x, NullableBoolean y)
		{
			if (x.HasValue != y.HasValue) //one is null
				return false;
			else if (x.HasValue) //therefor y also HasValue
				return x.Value == y.Value;
			else //both are null
				return true;
		}

		public static bool operator ==(NullableBoolean x, NullableBoolean y)
		{
			return x.Equals(y);
		}

		public static bool operator ==(NullableBoolean x, object y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(NullableBoolean x, NullableBoolean y)
		{
			return !x.Equals(y);
		}

		public static bool operator !=(NullableBoolean x, object y)
		{
			return !x.Equals(y);
		}
		
		public override int GetHashCode()
		{
			if (HasValue)
				return Value.GetHashCode();
			else
				return 0; //GetHashCode() doesn't garantee uniqueness, and neither do we.
		}

		//TODO: Operators for bool (or, and, xor, etc)
	}
}

[Nhibernate-commit] NHibernateContrib/src/Nullables.Tests/NHibernate NullablesClass.cs,NONE,1.1 NullablesClass.hbm.xml,NONE,1.1 NullablesFixture.cs,NONE,1.1 TestCase.cs,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables.Tests/NHibernate
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/src/Nullables.Tests/NHibernate

Added Files:
	NullablesClass.cs NullablesClass.hbm.xml NullablesFixture.cs 
	TestCase.cs 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: NullablesFixture.cs ---
using System;
using System.Collections;

using NHibernate;

using Nullables;
using NUnit.Framework;

namespace Nullables.Tests.NHibernate
{
	/// <summary>
	/// Summary description for NullablesFixture.
	/// </summary>
	[TestFixture]
	public class NullablesFixture : TestCase
	{
		[SetUp]
		public void SetUp()
		{
			ExportSchema(new string[] { "NullablesClass.hbm.xml"});
		}

		[Test]
		public void CRUD() 
		{
			NullablesClass nullNC = InitAllNull( 1 );
			NullablesClass notnullNC = InitAllValues( 2 );

			ISession s = sessions.OpenSession();
			s.Save( nullNC );
			s.Save( notnullNC );
			s.Flush();
			s.Close();

			s = sessions.OpenSession();

			Assert.AreEqual( 2, s.Find( "from NullablesClass" ).Count, "should be 2 in the db" );

			IQuery q = s.CreateQuery( "from NullablesClass as nc where nc.Int32Prop is null" );
			IList results = q.List();
			Assert.AreEqual( 1, results.Count, "only one null int32 in the db" );
			
			nullNC = (NullablesClass)results[0];

			// verify NH did store this fields as null and retrieved them as 
			// the nullable version type.
			Assert.AreEqual( NullableBoolean.Default, nullNC.BooleanProp );
			Assert.AreEqual( NullableByte.Default, nullNC.ByteProp );
			Assert.AreEqual( NullableDateTime.Default, nullNC.DateTimeProp );
			Assert.AreEqual( NullableDecimal.Default, nullNC.DecimalProp );
			Assert.AreEqual( NullableDouble.Default, nullNC.DoubleProp );
			Assert.AreEqual( NullableGuid.Default, nullNC.GuidProp );
			Assert.AreEqual( NullableInt16.Default, nullNC.Int16Prop);
			Assert.AreEqual( NullableInt32.Default, nullNC.Int32Prop );
			Assert.AreEqual( NullableInt64.Default, nullNC.Int64Prop );
			Assert.AreEqual( NullableSingle.Default, nullNC.SingleProp );

			Assert.AreEqual( 0, nullNC.Version );

			// don't change anything but flush it - should not increment
			// the version because there were no changes
			s.Flush();
			s.Close();

			s = sessions.OpenSession();
			nullNC = (NullablesClass)s.Find( "from NullablesClass" )[0];
			Assert.AreEqual( 0, nullNC.Version, "no changes to write at last flush - version should not have changed" );

			q = s.CreateQuery( "from NullablesClass as nc where nc.Int32Prop = :int32Prop" );
			q.SetParameter( "int32Prop", new NullableInt32( Int32.MaxValue) , Nullables.NHibernate.NullablesTypes.NullableInt32 );
			results = q.List();

			Assert.AreEqual( 1, results.Count );
			notnullNC = (NullablesClass)results[0];

			// change the Int32 properties
			nullNC.Int32Prop = 5;
			notnullNC.Int32Prop = null;

			s.Flush();
			s.Close();

			s = sessions.OpenSession();
			nullNC = (NullablesClass)s.Load( typeof(NullablesClass), 1 );
			notnullNC = (NullablesClass)s.Load( typeof(NullablesClass), 2 );

			Assert.IsTrue( 5==nullNC.Int32Prop, "should have actual value" );
			Assert.AreEqual( NullableInt32.Default, notnullNC.Int32Prop, "should have 'null' value" );


			// clear the table
			s.Delete( "from NullablesClass" );
			s.Flush();
			s.Close();
			
		}

		public NullablesClass InitAllNull(int id) 
		{

			NullablesClass nc = new NullablesClass();
			nc.Id = id;

			nc.BooleanProp = NullableBoolean.Default;
			nc.ByteProp = NullableByte.Default;
			nc.DateTimeProp = NullableDateTime.Default;
			nc.DecimalProp = NullableDecimal.Default;
			nc.DoubleProp = NullableDouble.Default;
			nc.GuidProp = NullableGuid.Default;
			nc.Int16Prop = NullableInt16.Default;
			nc.Int32Prop = NullableInt32.Default;
			nc.Int64Prop = NullableInt64.Default;
			nc.SingleProp = NullableSingle.Default;

			return nc;
		}

		public NullablesClass InitAllValues(int id) 
		{
			NullablesClass nc = new NullablesClass();
			nc.Id = id;

			nc.BooleanProp = true;
			nc.ByteProp = (byte)5;
			nc.DateTimeProp = DateTime.Parse( "2004-01-01" );
			nc.DecimalProp = 2.45M;
			nc.DoubleProp = 1.7E+3;
			nc.GuidProp = Guid.NewGuid();
			nc.Int16Prop = Int16.MaxValue;
			nc.Int32Prop = Int32.MaxValue;
			nc.Int64Prop = Int64.MaxValue;
			nc.SingleProp = 4.3f;

			return nc;
		}

	}
}

--- NEW FILE: NullablesClass.hbm.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: TestCase.cs ---
using System;
using System.Reflection;

using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;

using NUnit.Framework;

namespace Nullables.Tests.NHibernate
{
	/// <summary>
	/// Summary description for TestCase.
	/// </summary>
	public class TestCase
	{
		protected Configuration cfg;
		protected ISessionFactory sessions;

		/// <summary>
		/// Removes the tables used in this TestCase.
		/// </summary>
		/// <remarks>
		/// If the tables are not cleaned up sometimes SchemaExport runs into
		/// Sql errors because it can't drop tables because of the FKs.  This 
		/// will occur if the TestCase does not have the same hbm.xml files
		/// included as a previous one.
		/// </remarks>
		[TearDown]
		public virtual void TearDown() 
		{
			DropSchema();
		}

		public void ExportSchema(string[] files) 
		{
			ExportSchema(files, true);
		}

		public void ExportSchema(string[] files, bool exportSchema) 
		{
			cfg = new Configuration();

			for (int i=0; i<files.Length; i++) 
			{
				cfg.AddResource("Nullables.Tests.NHibernate." + files[i], Assembly.Load("Nullables.Tests"));
			}

			if(exportSchema) new SchemaExport(cfg).Create(true, true);
			
			sessions = cfg.BuildSessionFactory( );
		}

		/// <summary>
		/// Drops the schema that was built with the TestCase's Configuration.
		/// </summary>
		public void DropSchema() 
		{
			new SchemaExport(cfg).Drop(true, true);
		}
	}
}

--- NEW FILE: NullablesClass.cs ---
using System;

namespace Nullables.Tests.NHibernate
{
	/// <summary>
	/// Summary description for NullablesClass.
	/// </summary>
	public class NullablesClass
	{
		private int _id;
		private int _version;

		private NullableBoolean _booleanProp;
		private NullableByte _byteProp;
		private NullableDateTime _dateTimeProp;
		private NullableDecimal _decimalProp;
		private NullableDouble _doubleProp;
		private NullableGuid _guidProp;
		private NullableInt16 _int16Prop;
		private NullableInt32 _int32Prop;
		private NullableInt64 _int64Prop;
		private NullableSingle _singleProp;
		
		public NullablesClass()
		{
			
		}

		public int Id 
		{
			get { return _id; }
			set { _id = value; }
		}

		public int Version 
		{
			get { return _version; }
			set { _version = value; }
		}

		public NullableBoolean BooleanProp
		{
			get { return _booleanProp; }
			set { _booleanProp = value; }
		}

		public NullableByte ByteProp
		{
			get { return _byteProp; }
			set { _byteProp = value; }
		}

		public NullableDateTime DateTimeProp
		{
			get { return _dateTimeProp; }
			set { _dateTimeProp = value; }
		}

		public NullableDecimal DecimalProp
		{
			get { return _decimalProp; }
			set { _decimalProp = value; }
		}

		public NullableDouble DoubleProp
		{
			get { return _doubleProp; }
			set { _doubleProp = value; }
		}

		public NullableGuid GuidProp
		{
			get { return _guidProp; }
			set { _guidProp = value; }
		}

		public NullableInt16 Int16Prop
		{
			get { return _int16Prop; }
			set { _int16Prop = value; }
		}

		public NullableInt32 Int32Prop
		{
			get { return _int32Prop; }
			set { _int32Prop = value; }
		}

		public NullableInt64 Int64Prop
		{
			get { return _int64Prop; }
			set { _int64Prop = value; }
		}

		public NullableSingle SingleProp
		{
			get { return _singleProp; }
			set { _singleProp = value; }
		}

		

	}
}

[Nhibernate-commit] NHibernateContrib/src .cvsignore,NONE,1.1 Nullables-1.1.sln,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/src

Added Files:
	.cvsignore Nullables-1.1.sln 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: .cvsignore ---
*.suo

--- NEW FILE: Nullables-1.1.sln ---
Microsoft Visual Studio Solution File, Format Version 8.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nullables-1.1", "Nullables\Nullables-1.1.csproj", "{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nullables.Tests-1.1", "Nullables.Tests\Nullables.Tests-1.1.csproj", "{2D3FBB15-830A-4A9E-82D7-A0712B7330E1}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nullables.NHibernate-1.1", "Nullables.NHibernate\Nullables.NHibernate-1.1.csproj", "{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}"
	ProjectSection(ProjectDependencies) = postProject
	EndProjectSection
EndProject
Global
	GlobalSection(SolutionConfiguration) = preSolution
		Debug = Debug
		Release = Release
	EndGlobalSection
	GlobalSection(ProjectConfiguration) = postSolution
		{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}.Debug.ActiveCfg = Debug|.NET
		{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}.Debug.Build.0 = Debug|.NET
		{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}.Release.ActiveCfg = Release|.NET
		{9DEFA2EA-4A52-445A-8DA4-6531BD5D76B5}.Release.Build.0 = Release|.NET
		{2D3FBB15-830A-4A9E-82D7-A0712B7330E1}.Debug.ActiveCfg = Debug|.NET
		{2D3FBB15-830A-4A9E-82D7-A0712B7330E1}.Debug.Build.0 = Debug|.NET
		{2D3FBB15-830A-4A9E-82D7-A0712B7330E1}.Release.ActiveCfg = Release|.NET
		{2D3FBB15-830A-4A9E-82D7-A0712B7330E1}.Release.Build.0 = Release|.NET
		{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}.Debug.ActiveCfg = Debug|.NET
		{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}.Debug.Build.0 = Debug|.NET
		{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}.Release.ActiveCfg = Release|.NET
		{35F82297-CAB4-4D57-AAB9-CBDB1F6B8841}.Release.Build.0 = Release|.NET
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
	EndGlobalSection
	GlobalSection(ExtensibilityAddIns) = postSolution
	EndGlobalSection
EndGlobal

[Nhibernate-commit] NHibernateContrib .cvsignore,NONE,1.1 lgpl.txt,NONE,1.1 NHibernateContribSolution.build,NONE,1.1 readme.html,NONE,1.1 releasenotes.txt,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720

Added Files:
	.cvsignore lgpl.txt NHibernateContribSolution.build 
	readme.html releasenotes.txt 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: readme.html ---
<html>
	<body>
		<h1>Welcome to NHibernateContrib.</h1>
		<hr>
		<p>
			The NHibernateContrib is various programs contributed to NHibernate by the end users.  The
			projects in here are not considered core pieces of NHibernate but they extend it in a useful
			way.			
		</p>
		<p>
			The current projects are:
		</p>
		<ul>
			<li>
				Nullables: A library of Nullable version of the ValueTypes in net-1.1.  It is meant to serve as 
				a bridge until .net-2.0 comes out with their own Nullables.
			</li>
			<li>
				Nullables.NHibernate:  A library of NHibernate Types for the Nullables.
			</li>
			<li>
				Nullables.Tests:  A library of NUnit Tests for Nullables and Nullables.NHibernate.
			</li>
		</ul>
		
		
		</li>
		<h2>Latest Version</h2>
		<p>
			Details of the latest version of NHibernateContrib can be found on SourceForge at 
			<a href="http://sourceforge.net/projects/nhibernate">http://sourceforge.net/projects/nhibernate</a>.
		</p>
		<h2>Documentation</h2>
		<p>
			The API of the components in NHibernateContrib is in MSDN format thanks to 
			<a href="http://sourceforge.net/projects/ndoc">NDoc</a>.
		</p>
		
		<h2>Bug Reports</h2>
		<p>
			As we mentioned before, this software is still being developed. So if you do 
			find any bugs please use the 
			<a href="http://jira.nhibernate.org/">JIRA bug tracker</a> and put them in the contrib component.
		</p>
		<h2>Licenses</h2>
		<p>
			This software is distributed under the terms of the FSF Lesser Gnu Public 
			License (see lgpl.txt).
		</p>
		<p>
			This product uses software developed by the Apache Software Foundation 
			(http://www.apache.org/).
		</p>
		<ul>
			<li>log4net</li>
		</ul>
	</body>
</html>

--- NEW FILE: lgpl.txt ---
		  GNU LESSER GENERAL PUBLIC LICENSE
		       Version 2.1, February 1999

 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

  This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

  When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

  To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

  For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

  We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

  To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

  Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

  Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

  When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

  We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

  For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

  In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

  Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

  The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

		  GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

  A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

  The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

  "Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

  Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.
  
  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

  You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

  2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) The modified work must itself be a software library.

    b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

    c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

    d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

  Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

  This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

  4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

  If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

  5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

  Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

  6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

  You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

    a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

    c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

    d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

    e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

  For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

  7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

    a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

    b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

  8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

  9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

  10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

  11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

  13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

  14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

			    NO WARRANTY

  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

		     END OF TERMS AND CONDITIONS

           How to Apply These Terms to Your New Libraries

  If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).

  To apply these terms, attach the following notices to the library.  It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.

    <one line to give the library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

  <signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice

That's all there is to it!



--- NEW FILE: releasenotes.txt ---
Build 0.5.0.0
======================== 
- Initial release of Nullables and Nullables.NHibernate
--- NEW FILE: .cvsignore ---
build

--- NEW FILE: NHibernateContribSolution.build ---
(This appears to be a binary file; contents omitted.)

[Nhibernate-commit] NHibernateContrib/lib/net/1.1 HashCodeProvider.dll,NONE,1.1 HashCodeProvider.license.txt,NONE,1.1 log4net.dll,NONE,1.1 log4net.xml,NONE,1.1 NHibernate.dll,NONE,1.1 NHibernate.xml,NONE,1.1 nunit.framework.dll,NONE,1.1

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/lib/net/1.1
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21720/lib/net/1.1

Added Files:
	HashCodeProvider.dll HashCodeProvider.license.txt log4net.dll 
	log4net.xml NHibernate.dll NHibernate.xml nunit.framework.dll 
Log Message:
NH-15: created a NHibernateContrib folder in cvs

--- NEW FILE: NHibernate.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: NHibernate.xml ---
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NHibernate</name>
    </assembly>
    <members>
        <member name="T:NHibernate.Cache.CachedItem">
            <summary>
            An item of cached data, timestamped with the time it was cached, when it was locked,
            when it was unlocked
            </summary>
        </member>
        <member name="M:NHibernate.Cache.CachedItem.Lock">
            <summary>
            Lock the Item.
            </summary>
        </member>
        <member name="M:NHibernate.Cache.CachedItem.Unlock">
            <summary>
[...11548 lines suppressed...]
        <member name="T:NHibernate.TransientObjectException">
            <summary>
            Throw when the user passes a transient instance to a <c>ISession</c> method that expects
            a persistent instance
            </summary>
        </member>
        <member name="T:NHibernate.ValidationFailure">
            <summary>
            Thrown from <c>IValidatable.Validate()</c> when an invariant was violated. Some applications
            might subclass this exception in order to provide more information about the violation
            </summary>
        </member>
        <member name="T:NHibernate.WrongClassException">
            <summary>
            Thrown when <c>ISession.Load()</c> selects a row with the given primary key (identifier value)
            but the row's discriminator value specifies a different subclass from the one requested
            </summary>
        </member>
    </members>
</doc>

--- NEW FILE: log4net.xml ---
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>log4net</name>
    </assembly>
    <members>
        <member name="T:log4net.Appender.ADONetAppender">
            <summary>
            Appender that logs to a database.
            </summary>
            <remarks>
            <para>
            <see cref="T:log4net.Appender.ADONetAppender"/> appends logging events to a table within a
            database. The appender can be configured to specify the connection 
            string by setting the <see cref="P:log4net.Appender.ADONetAppender.ConnectionString"/> property. 
            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.ADONetAppender.ConnectionType"/>
            property. For more information on database connection strings for
            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
            </para>
[...14753 lines suppressed...]
            <param name="frameStack">The internal stack used by the NDC.</param>
            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
        </member>
        <member name="M:log4net.NDC.NDCAutoDisposeFrame.Dispose">
            <summary>
            Returns the NDC stack to the correct depth.
            </summary>
        </member>
        <member name="F:log4net.NDC.NDCAutoDisposeFrame.m_frameStack">
            <summary>
            The NDC internal stack
            </summary>
        </member>
        <member name="F:log4net.NDC.NDCAutoDisposeFrame.m_frameDepth">
            <summary>
            The depth to rethrow the stack to when this instance is disposed
            </summary>
        </member>
    </members>
</doc>

--- NEW FILE: HashCodeProvider.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: HashCodeProvider.license.txt ---
Copyright (c) 2002 Mattias Sjogren

This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial applications, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

2. No substantial portion of the source code may be redistributed without the express written permission of the copyright holders, where "substantial" is defined as enough code to be recognizably from this library.

--- NEW FILE: nunit.framework.dll ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: log4net.dll ---
(This appears to be a binary file; contents omitted.)

[Nhibernate-commit] NHibernateContrib/src/Nullables.Tests/NHibernate - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables.Tests/NHibernate
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16116/NHibernate

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/src/Nullables.Tests/NHibernate added to the repository

[Nhibernate-commit] NHibernateContrib/src/Nullables/TypeConverters - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables/TypeConverters
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16078/TypeConverters

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/src/Nullables/TypeConverters added to the repository

[Nhibernate-commit] NHibernateContrib/src/Nullables.Tests - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables.Tests
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16022/Nullables.Tests

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/src/Nullables.Tests added to the repository

[Nhibernate-commit] NHibernateContrib/src/Nullables.NHibernate - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables.NHibernate
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15947/Nullables.NHibernate

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/src/Nullables.NHibernate added to the repository

[Nhibernate-commit] NHibernateContrib/src/Nullables - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/Nullables
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15915/Nullables

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/src/Nullables added to the repository

[Nhibernate-commit] NHibernateContrib/src - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15756/src

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/src added to the repository

[Nhibernate-commit] NHibernateContrib/lib/net/1.1 - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/lib/net/1.1
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15698/1.1

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/lib/net/1.1 added to the repository

[Nhibernate-commit] NHibernateContrib/lib/net - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/lib/net
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15656/net

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/lib/net added to the repository

[Nhibernate-commit] NHibernateContrib/lib - New directory

[Michael D. <mik...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/lib
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15601/lib

Log Message:
Directory /cvsroot/nhibernate/NHibernateContrib/lib added to the repository