/// <summary>
    /// Use this filter to simulate slow connections
    /// </summary>
    public class BandwidthThrottleFilter : Stream
    {
        private readonly int _bytesPerSecond;
        private readonly Stream _sink;

        /// <summary>
        /// Gets a slow reading stream
        /// </summary>
        /// <param name="sink">a stream to use as a base (like Response.Filter)</param>
        /// <param name="bytesPerSecond">number of maximum bytes per second</param>
        public BandwidthThrottleFilter(Stream sink, int bytesPerSecond)
        {
            _sink = sink;
            _bytesPerSecond = bytesPerSecond;
        }


        private void Delay(int length)
        {
            int milliseconds = length*1000/_bytesPerSecond;
            if (milliseconds>0) Thread.Sleep(milliseconds);
        }


        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports reading.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports reading; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanRead
        {
            get { return _sink.CanRead; }
        }

        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports seeking.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports seeking; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanSeek
        {
            get { return _sink.CanSeek; }
        }

        ///<summary>
        ///When overridden in a derived class, gets a value indicating whether the current stream supports writing.
        ///</summary>
        ///
        ///<returns>
        ///true if the stream supports writing; otherwise, false.
        ///</returns>
        ///<filterpriority>1</filterpriority>
        public override bool CanWrite
        {
            get { return _sink.CanWrite; }
        }

        ///<summary>
        ///When overridden in a derived class, gets the length in bytes of the stream.
        ///</summary>
        ///
        ///<returns>
        ///A long value representing the length of the stream in bytes.
        ///</returns>
        ///
        ///<exception cref="T:System.NotSupportedException">A class derived from Stream does not support seeking. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Length
        {
            get { return _sink.Length; }
        }

        ///<summary>
        ///When overridden in a derived class, gets or sets the position within the current stream.
        ///</summary>
        ///
        ///<returns>
        ///The current position within the stream.
        ///</returns>
        ///
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support seeking. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Position
        {
            get { return _sink.Position; }
            set { _sink.Position = value; }
        }


        ///<summary>
        ///When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device.
        ///</summary>
        ///
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception><filterpriority>2</filterpriority>
        public override void Flush()
        {
            _sink.Flush();
        }

        ///<summary>
        ///When overridden in a derived class, sets the position within the current stream.
        ///</summary>
        ///
        ///<returns>
        ///The new position within the current stream.
        ///</returns>
        ///
        ///<param name="offset">A byte offset relative to the origin parameter. </param>
        ///<param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"></see> indicating the reference point used to obtain the new position. </param>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support seeking, such as if the stream is constructed from a pipe or console output. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>1</filterpriority>
        public override long Seek(long offset, SeekOrigin origin)
        {
            return _sink.Seek(offset, origin);
        }

        ///<summary>
        ///When overridden in a derived class, sets the length of the current stream.
        ///</summary>
        ///
        ///<param name="value">The desired length of the current stream in bytes. </param>
        ///<exception cref="T:System.NotSupportedException">The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. </exception>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception><filterpriority>2</filterpriority>
        public override void SetLength(long value)
        {
            _sink.SetLength(value);
        }

        ///<summary>
        ///When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
        ///</summary>
        ///
        ///<returns>
        ///The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
        ///</returns>
        ///
        ///<param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream. </param>
        ///<param name="count">The maximum number of bytes to be read from the current stream. </param>
        ///<param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source. </param>
        ///<exception cref="T:System.ArgumentException">The sum of offset and count is larger than the buffer length. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support reading. </exception>
        ///<exception cref="T:System.ArgumentNullException">buffer is null. </exception>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.ArgumentOutOfRangeException">offset or count is negative. </exception><filterpriority>1</filterpriority>
        public override int Read(byte[] buffer, int offset, int count)
        {
            return _sink.Read(buffer, offset, count);
        }

        ///<summary>
        ///When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
        ///</summary>
        ///
        ///<param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream. </param>
        ///<param name="count">The number of bytes to be written to the current stream. </param>
        ///<param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream. </param>
        ///<exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
        ///<exception cref="T:System.NotSupportedException">The stream does not support writing. </exception>
        ///<exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
        ///<exception cref="T:System.ArgumentNullException">buffer is null. </exception>
        ///<exception cref="T:System.ArgumentException">The sum of offset and count is greater than the buffer length. </exception>
        ///<exception cref="T:System.ArgumentOutOfRangeException">offset or count is negative. </exception><filterpriority>1</filterpriority>
        public override void Write(byte[] buffer, int offset, int count)
        {
            Delay(count);
            _sink.Write(buffer, offset, count);
        }
    }

namespace Siderite.Text.RegularExpressions
{
/// <summary>
/// Regex Match equivalent for Streams
/// </summary>
public class StreamMatch
{
private readonly Match _match;
private readonly StreamRegex _streamRegex;
private long _streamIndex;

/// <summary>
/// Constructor
/// </summary>
/// <param name="regex">StreamRegex that generated it</param>
/// <param name="m">internal Regex match</param>
/// <param name="streamIndex">real stream index</param>
internal StreamMatch(StreamRegex regex, Match m, long streamIndex)
{
_streamRegex = regex;
_match = m;
StreamIndex = streamIndex;
}

/// <summary>
/// Empty StreamMatch
/// </summary>
public static StreamMatch Empty
{
get { return new StreamMatch(null, null,0); }
}

/// <summary>
/// Success of matching
/// </summary>
public bool Success
{
get
{
if (_match == null) return false;
// matches with length 0 would only cause infinite loops
if ((_streamRegex.EmptyRegexMode==EmptyRegexMode.NoSuccess)&&(_match.Length == 0)) 
return false;
return _match.Success;
}
}

/// <summary>
/// Length of match
/// </summary>
public int Length
{
get
{
if (_match == null) return 0;
return _match.Length;
}
}

/// <summary>
/// Groups in the match. This is a regular Regex GroupCollection
/// </summary>
public GroupCollection Groups
{
get
{
if (_match == null) return null;
return _match.Groups;
}
}

/// <summary>
/// Value of the match
/// </summary>
public string Value
{
get
{
if (_match == null) return null;
return _match.Value;
}
}

/// <summary>
/// Group names in the match including "0","1", etc
/// </summary>
public string[] GroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.GroupNames;
}
}

/// <summary>
/// Group names in the match that are non numeric (words only)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.NonNumericGroupNames;
}
}

public long StreamIndex
{
get { return _streamIndex; }
set { _streamIndex = value; }
}

/// <summary>
/// indexer using a name
/// </summary>
/// <param name="groupName"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[string groupName]
{
get
{
if (_match == null) return null;
return _match.Groups[groupName];
}
}

/// <summary>
/// indexer using a numeric index
/// </summary>
/// <param name="groupNr"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[int groupNr]
{
get
{
if (_match == null) return null;
return _match.Groups[groupNr];
}
}

/// <summary>
/// Find next match
/// </summary>
/// <returns></returns>
public StreamMatch NextMatch()
{
if (_streamRegex == null) return null;
return _streamRegex.NextMatch();
}
}

public enum EmptyRegexMode
{
NoSuccess,
ThrowException,
Success
}

/// <summary>
/// Regex equivalent for Streams
/// </summary>
public class StreamRegex
{
private readonly Regex _regex;
private readonly StringBuilder _sb;
private readonly Stream _stream;
private byte[] _buffer;
private int _bufferSize = 65536;
private long _currentPosition;
private Encoding _encoding;
private string[] _groupNames;
private long _internalStreamLength;
private bool _matchInitialised;
private long _maxMatchLength;
private EmptyRegexMode _emptyRegexMode;

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
public StreamRegex(Stream stream, string pattern)
: this(stream, pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Compiled)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions)
: this(stream, pattern, regexOptions, Encoding.GetEncoding(1252))
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding)
: this(stream, pattern, regexOptions, encoding, long.MaxValue/2)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
/// <param name="maxMatchLength">Maximum possible match. Specify this to minimize memory use</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding,
long maxMatchLength)
{
_regex = new Regex(pattern, regexOptions);
_stream = stream;
_matchInitialised = false;
Encoding = encoding;
MaxMatchLength = maxMatchLength;
_sb = new StringBuilder();
EmptyRegexMode = EmptyRegexMode.NoSuccess;
}

/// <summary>
/// Read buffer size. default 65536 bytes
/// Warning: this works on an internal string that will be 
/// a multiple of this number. Don't make it too large.
/// </summary>
public int BufferSize
{
get { return _bufferSize; }
set
{
_bufferSize = value;
// you cannot run NextMatch now
_matchInitialised = false;
}
}

/// <summary>
/// Encoding for the stream. default Windows-1252
/// </summary>
public Encoding Encoding
{
get { return _encoding; }
set { _encoding = value; }
}

/// <summary>
/// Maximum possible match length. default long.MaxValue/2
/// </summary>
public long MaxMatchLength
{
get { return _maxMatchLength; }
set { _maxMatchLength = value; }
}

/// <summary>
/// Names of the groups in the regex expression
/// </summary>
public string[] GroupNames
{
get
{
if (_regex == null) return null;
if (_groupNames == null)
{
_groupNames = _regex.GetGroupNames();
}
return _groupNames;
}
}

/// <summary>
/// Names of the groups in the regex expression
/// that are non numeric (so only the word names)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_regex == null) return null;
List<string> list = new List<string>();
foreach (string groupName in _regex.GetGroupNames())
{
if (!Regex.IsMatch(groupName, @"^\d+$")) list.Add(groupName);
}
return list;
}
}

/// <summary>
/// defines who empty matches are treated: 
/// no success match, exception or succesful match
/// defaults to no success match
/// </summary>
public EmptyRegexMode EmptyRegexMode
{
get { return _emptyRegexMode; }
set { _emptyRegexMode = value; }
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <returns></returns>
public StreamMatch Match()
{
return Match(0L);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public StreamMatch Match(long index)
{
return Match(index, long.MaxValue/2);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public StreamMatch Match(long index, long length)
{
if (!_stream.CanRead) throw new Exception("Stream is not readable");
if (length <= 0) return StreamMatch.Empty;
if (index != 0) SeekStream(index);
_buffer = new byte[BufferSize];
_sb.Length = 0;
// initialize real position in stream
_currentPosition = _stream.Position;
// this is the maximum length of bytes this match will read
_internalStreamLength = length;
// you can now call NextMatch
_matchInitialised = true;
return NextMatch();
}

internal StreamMatch NextMatch()
{
if (!_matchInitialised) 
throw new Exception("First run Match, then NextMatch");
// search the buffer string first
Match m = _regex.Match(_sb.ToString());
if (m.Success&&((EmptyRegexMode!=EmptyRegexMode.NoSuccess)||(m.Length>0)))
{
if (EmptyRegexMode == EmptyRegexMode.ThrowException)
{
if (m.Length == 0)
throw new Exception(
"Successful Match has empty value. If you use NextMatch in a loop it will become infinite");
}
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;

return sm;
}
int l;
while ((l = _stream.Read(_buffer, 0, (int) Math.Min(_internalStreamLength, _buffer.Length))) > 0)
{
_internalStreamLength -= l;

// remove part of StringBuilder where there is no chance it contains a match
// this works only if MaxMatch is specified
long extraLength = _sb.Length - MaxMatchLength;
if (extraLength > 0)
{
_sb.Remove(0, (int) extraLength);
_currentPosition += extraLength;
}


_sb.Append(Encoding.GetString(_buffer, 0, l));

// TODO: remove this
Debug.WriteLine("SB length: " + _sb.Length);

m = _regex.Match(_sb.ToString());
if (m.Success)
{
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;
return sm;
}
}
return new StreamMatch(this, m, 0);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches()
{
return Matches(0L);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index)
{
return Matches(index, long.MaxValue/2);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index, long length)
{
List<StreamMatch> list = new List<StreamMatch>();
StreamMatch m = Match(index, length);
while (m.Success)
{
list.Add(m);
m = NextMatch();
}
return list;
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index from current position</param>
public void SeekStream(long index)
{
SeekStream(index, SeekOrigin.Current);
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index position</param>
/// <param name="origin">from current position, start or end</param>
public void SeekStream(long index, SeekOrigin origin)
{
int _tmpSeekSize = 65536;
if (_stream.CanSeek)
{
_stream.Seek(index, origin);
}
else
{
if (origin != SeekOrigin.Current) throw new Exception("Stream is not seakable");
long l = 0;
try
{
l = _stream.Length;
}
#pragma warning disable EmptyGeneralCatchClause
catch (Exception)
{
}
#pragma warning restore EmptyGeneralCatchClause
if ((l > 0) && (l < 65536)) _tmpSeekSize = 4096;
if (l > 1000000) _tmpSeekSize = 409600;
if (index >= 0)
{
byte[] buff = new byte[_tmpSeekSize];
l = index;
while (l > 0)
{
l -= _stream.Read(buff, 0, (int) Math.Min(l, buff.Length));
}
}
else
{
throw new Exception("begin cannot be negative on a non seeking stream");
}
}

// update real position in stream
_currentPosition = _stream.Position;
// you cannot run NextMatch now
_matchInitialised = false;
}
}
}

using System;
using System.Data.SqlTypes;

namespace Siderite.Util
{
    ///<summary>
    /// Wraps a nullable type so that it can be passed as a method parameter
    ///</summary>
    [Serializable]
    public class NullableWrapper
    {
        private Type _underlyingType;
        private object _wrappedValue;

        private NullableWrapper()
        {
        }

        ///<summary>
        /// The underlying type in the nullable type
        ///</summary>
        public Type UnderlyingType
        {
            get { return _underlyingType; }
            set { _underlyingType = value; }
        }

        ///<summary>
        /// The value inside the nullable type
        ///</summary>
        public object WrappedValue
        {
            get { return _wrappedValue; }
            set { _wrappedValue = value; }
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Byte> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Byte);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int16> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int16);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int32> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int32);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int64> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int64);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt16> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt16);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt32> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt32);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt64> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt64);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Single> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Single);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Double> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Double);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Decimal> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Decimal);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Boolean> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Boolean);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Char> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Char);
            nw.WrappedValue = obj ?? null;
            return nw;
        }


        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<IntPtr> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (IntPtr);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UIntPtr> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UIntPtr);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Return the Sql Server typed value from the wrapped nullable type
        ///</summary>
        ///<returns></returns>
        ///<exception cref="Exception"></exception>
        public object GetSqlValue()
        {
            if (UnderlyingType == null) return DBNull.Value;
            switch (UnderlyingType.FullName)
            {
                case "System.Byte":
                    return WrappedValue == null
                               ? SqlByte.Null
                               : new SqlByte((byte) WrappedValue);
                case "System.SByte":
                    return WrappedValue == null
                               ? SqlInt16.Null
                               : new SqlInt16((sbyte) WrappedValue);
                case "System.Int16":
                    return WrappedValue == null
                               ? SqlInt16.Null
                               : new SqlInt16((Int16) WrappedValue);
                case "System.Int32":
                    return WrappedValue == null
                               ? SqlInt32.Null
                               : new SqlInt32((Int32) WrappedValue);
                case "System.Int64":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64((Int64) WrappedValue);
                case "System.UInt16":
                    return WrappedValue == null
                               ? SqlInt32.Null
                               : new SqlInt32((UInt16) WrappedValue);
                case "System.UInt32":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64((UInt32) WrappedValue);
                case "System.UInt64":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64(((Int64) WrappedValue));
                case "System.Single":
                    return WrappedValue == null
                               ? SqlSingle.Null
                               : new SqlSingle(((Single) WrappedValue));
                case "System.Double":
                    return WrappedValue == null
                               ? SqlDouble.Null
                               : new SqlDouble(((Double) WrappedValue));
                case "System.Decimal":
                    return WrappedValue == null
                               ? SqlDecimal.Null
                               : new SqlDecimal(((Decimal) WrappedValue));
                case "System.Boolean":
                    return WrappedValue == null
                               ? SqlBoolean.Null
                               : new SqlBoolean(((Boolean) WrappedValue));
                case "System.Char":
                    return WrappedValue == null
                               ? SqlString.Null
                               : new SqlString(((Char) WrappedValue).ToString());
                case "System.String":
                    return WrappedValue == null
                               ? SqlString.Null
                               : new SqlString(((String) WrappedValue));
                default:
                    throw new Exception("Unsupported type " 
                        + UnderlyingType.FullName);
            }
        }
    }
}