domino-webservice引用%INCLUDE "lsxsd.lss"是什么意思

个人猜测domino-webservice引用%INCLUDE "lsxsd.lss" 为了补充lotusscript语音和其他开发语言的差距，所以需要补充代码库。

在使用引用追加新的类库。

lsxsd.lss在domino-notes开发环境下可以找到，内容如。其中一些追加新的类。

（感谢QQ群友解惑）

%INCLUDE "lserr.lss"

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' USEFUL DATA CONVERSIONS USED BY ONE OR MORE XML SCHEMA DATATYPES
'--------------------------------------------------------------------
'--------------------------------------------------------------------
CLASS XSD_DATATYPE_CONVERTER
	
	' Convert bytes in a NotesStream into a base64 string
	Function notesStreamToBase64 (ns As NotesStream) As String
		
		Const b64Chars$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
		
		Dim nsLength As Long
		nsLength = ns.Bytes
		ns.Position = 0
		
		Dim numPads As Integer
		numPads = (3 - (nsLength Mod 3)) Mod 3
		
		While nsLength > 0
			
			' Output lines are limited to 76 chars, and because every
			' three input bytes produce 4 output chars we process
			' up to 57 input bytes at a time. (57 = 76 / 4 * 3)
			
			Dim inLength As Long
			inLength = nsLength
			If inLength > 57 Then inLength = 57
			nsLength = nsLength - inLength
			
			Dim outString As String
			outString = ""
			Dim idx As Integer
			idx = 0
			While idx < inLength
				
				' Collect up to 24 bits (3 bytes) of input data
				Dim outBits As Integer
				outBits = 0
				Dim bits24 As Long
				bits24 = 0
				Dim i As Integer
				For i = 0 To 2
					bits24 = bits24 * 256
					If idx + i < inLength Then
						Dim buf As Variant
						buf = ns.Read(1&)
						bits24 = bits24 + buf(0)
						outBits = outBits + 8
					End If
				Next
				idx = idx + 3
				
				Dim numChars As Integer
				numChars = 4
				If outBits <> 24 Then
					numChars = 4 - numPads
				End If
				
				For i = 1 To numChars
					Dim bits6 As Integer
					bits6 = (bits24 And &HFC0000&) / 262144
					outString = outString & Mid$(b64Chars, bits6 + 1, 1)
					bits24 = (bits24 And &H3FFFF&) * 64
				Next
				
				If numChars <> 4 Then
					For i = 1 To numPads
						outString = outString & "="
					Next
				End If
				
			Wend
			
			' Add another line of base64 output to the return string
			notesStreamToBase64 = notesStreamToBase64 & outString & Chr$(13) & Chr$(10)
			
		Wend
		
	End Function
	
	' Convert bytes in a NotesStream into a base64 string
	Function notesStreamToBase64Ext (ns As NotesStream) As String
		On Error GoTo Fallback
		notesStreamToBase64Ext = ns.ReadEncoded(ENC_BASE64, 76) 'internal use only
		Exit Function
	  Fallback:
		On Error GoTo ExitFunction
		notesStreamToBase64Ext = Me.notesStreamtoBase64(ns)
		Exit Function
	  ExitFunction:
		notesStreamToBase64Ext = ""
	End Function


	' Convert a base64 string into bytes in a NotesStream
	Function base64ToNotesStream (b64String As String) As NotesStream
		
		Dim session As New NotesSession
		Dim ns As NotesStream
		Set ns = session.CreateStream
		
		' variables used to stage output to the NotesStream
		Redim buf (0 To 2) As Byte
		Dim numPads As Integer
		numPads = 0
		
		Dim b64Len As Long
		b64Len = Len(b64String)
		
		Dim idx As Long
		idx = 1
		While idx <= b64Len
			
			Dim currChar As String
			currChar = Mid$(b64String, idx, 1)
			
			' Ignore whitespace (CR, LF, SPACE, or TAB) that may lead the line		
			Dim c As Long
			c = Asc(currChar)
			If c = 13 Or c = 10 Or c = 32 Or c = 9 Then
				idx = idx + 1
				Goto Next1
			End If
			
			' Every 4 base64 characters represent 24 bits (three 8-bit bytes)
			Dim bits24 As Long
			bits24 = 0
			Dim i As Integer
			For i = 0 To 3
				Dim bits6 As Long
				c = Asc(Mid$(b64String, idx, 1))
				idx = idx + 1
				
				' Map characters "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
				' to 6-bit binary values ranging from 0 to 63, respectively
				Select Case c
				Case Asc("A") To Asc("Z")
					bits6 = c - Asc("A")				' map A-Z to 0-25
				Case  Asc("a") To Asc("z")
					bits6 = 26 + c - Asc("a")		' map a-z to 26-51
				Case Asc("0") To Asc("9")
					bits6 = 52 + c - Asc("0")		' map 0-9 to 52-61
				Case Asc("+")
					bits6 = 62		' map "+" to 62
				Case Asc("/")
					bits6 = 63		' map "/" to 63
				Case Asc("=")			' pad char at end of base64
					bits6 = 0
					numPads = numPads + 1
				Case Else
					Error ErrOverflow
				End Select
				bits24 = (bits24 * 64) + bits6
			Next
			
			' Extract three 8-bit bytes from the 24-bit value					
			buf(0) = (bits24 And &HFF0000&) / 65536
			buf(1) = (bits24 And &H00FF00&) / 256
			buf(2) = bits24 And &H0000FF&
			
			' Write up to three 8-bit bytes to the NotesStream					
			Select Case numPads
			Case 0
				Call ns.Write (buf)
			Case 1
				Redim Preserve buf (0 To 1)
				Call ns.Write (buf)
				Goto done
			Case 2
				Redim Preserve buf (0 To 0)
				Call ns.Write (buf)
				Goto done
			End Select
			
next1:
		Wend
		
done:
		Set base64ToNotesStream = ns
		
	End Function

	' Convert a base64 string into bytes in a NotesStream
	Function base64ToNotesStreamExt (b64String As String) As NotesStream
		
		Dim session As New NotesSession
		Dim ns As NotesStream
		Set ns = session.CreateStream
		On Error GoTo Fallback
		Call ns.WriteDecoded(b64String,ENC_BASE64) 'internal use only
		Set base64ToNotesStreamExt = ns
		Exit Function
	  Fallback:
		On Error GoTo ExitFunction
		Set base64ToNotesStreamExt = Me.base64ToNotesStream(b64String)
		Exit Function
	  ExitFunction:
		Set base64ToNotesStreamExt = session.CreateStream
	End Function
	
	' Convert bytes in a NotesStream into a hexBinary string
	Function notesStreamToHexBinary (ns As NotesStream) As String
		
		Const hexChars$ = "0123456789ABCDEF"
		
		Dim nsLength As Long
		nsLength = ns.Bytes
		ns.Position = 0
		
		While nsLength > 0
			
			' We arbitrarily limit output lines to 76 hex chars
			' by inserting CRLF after processing a run of 38
			' bytes. (Note: whitespace is allowed in hexBinary).
			
			Dim inLength As Long
			inLength = nsLength
			If inLength > 38 Then inLength = 38
			nsLength = nsLength - inLength
			
			Dim outString As String
			outString = ""
			Dim idx As Integer
			idx = 0
			While idx < inLength
				Dim buf As Variant
				buf = ns.Read(1&)
				outString = outString &_
				Mid$(hexChars, (buf(0) And &HF0&)/16+1,1) &_
				Mid$(hexChars, (buf(0) And &HF&)+1,1)
				idx = idx + 1				
			Wend
			
			' Add another line of base64 output to the return string
			notesStreamToHexBinary = notesStreamToHexBinary & outString & Chr$(13) & Chr$(10)
			
		Wend
		
	End Function


	' Convert a hexBinary string into bytes in a NotesStream
	Function hexBinaryToNotesStream (hexString As String) As NotesStream
		
		Dim session As New NotesSession
		Dim ns As NotesStream
		Set ns = session.CreateStream
		
		' variables used to stage output to the NotesStream
		Dim buf (0 To 0) As Byte
		
		Dim hexLen As Long
		hexLen = Len(hexString)
		
		Dim idx As Long
		idx = 1
		While idx <= hexLen
			
			' Ignore whitespace (CR, LF, SPACE, or TAB) that may lead the line		
			Dim c As Long
			c = Asc(Mid$(hexString, idx, 1))
			If c = 13 Or c = 10 Or c = 32 Or c = 9 Then
				idx = idx + 1
				Goto Next1
			End If
			
			' Every 2 hexBinary characters represent 1 8-bit byte
			buf(0) = 0
			Dim i As Integer
			For i = 0 To 1
				buf(0) = buf(0) * 16
				c = Asc(Mid$(hexString, idx+i, 1))
				Select Case c
				Case Asc("0") To Asc("9")
					buf(0) = buf(0) + c - Asc("0")
				Case Asc("A") To Asc("F")
					buf(0) = buf(0) + c - Asc("A") + 10
				End Select
			Next
			idx = idx + 2
			Call ns.Write(buf)
			
next1:
		Wend
		
done:
		Set hexBinaryToNotesStream = ns
		
	End Function

	' Set the date part of a NotesDateTime From "CCYY-MM-DD ..."
	' Uses localized date separators.
	Sub setXSDDate (ndt As NotesDateTime, xsddate As String)
		If Not ndt.IsValidDate Then ndt.LocalTime = ""
		Dim timeonly As String
		timeonly = ndt.TimeOnly	' preserve the time part
		Dim s As New notessession
		Dim intl As NotesInternational
		Set intl = s.International
	
		Dim datesep As String
		Let datesep = intl.DateSep
		Dim TmpDate As String	
	
		If (Intl.IsDateDMY) Then
			TmpDate = Mid$(xsddate,9,2)   'Day
			TmpDate = TmpDate  & datesep &_
			Mid$(xsddate,6,2)               'Month
			TmpDate = TmpDate & datesep &_
			Left$(xsddate,4)                   'Year			
		Elseif (Intl.IsDateYMD) Then
			TmpDate = Left$(xsddate,4)   'Year
			TmpDate = TmpDate  & datesep &_
			Mid$(xsddate,6,2)               'Month
			TmpDate = TmpDate & datesep &_
			Mid$(xsddate,9,2)                   'Day
		Else
			TmpDate = Mid$(xsddate,6,2)   'Month
			TmpDate = TmpDate  & datesep &_
			Mid$(xsddate,9,2)               'Day
			TmpDate = TmpDate & datesep &_
			Left$(xsddate,4)                   'Year			
		End If	
	
		ndt.LocalTime = TmpDate
	End Sub
	
	' Return the date part of a NotesDateTime as "CCYY-MM-DD"
	Function getXSDDate (ndt As NotesDateTime) As String
		If Not ndt.IsValidDate Then Error ErrTypeMismatch
		Dim vdatetime As Variant
		vdatetime = ndt.LSLocalTime
		getXSDDate = Format$(Year(vdatetime),"0000") & "-" &_
		Format$(Month(vdatetime),"00") & "-" &_
		Format$(Day(vdatetime),"00")
	End Function
	
	' Return the date part of a NotesDateTime as "CCYY-MM-DD" + timezone part
	Function getXSDZoneDate (ndt As NotesDateTime) As String
		If Not ndt.IsValidDate Then Error ErrTypeMismatch
		Dim vdatetime As Variant
		Dim ndtCopy As New NotesDateTime(ndt.GMTTime)
		If (Abs(ndt.TimeZone) > 99) Then
			ndtCopy.AdjustHour(-1 * (ndt.TimeZone Mod 100))
			ndtCopy.AdjustMinute(-1 * (ndt.TimeZone/100))
		Else
			ndtCopy.AdjustHour(-1 * ndt.TimeZone)			
		End If
		If (ndt.IsDST) Then
			ndtCopy.AdjustHour(1)
		End If
		vdatetime = ndtCopy.LSGMTTime  'adjusted to the zone time
	
		getXSDZoneDate = Format$(Year(vdatetime),"0000") & "-" &_
		Format$(Month(vdatetime),"00") & "-" &_
		Format$(Day(vdatetime),"00")
	End Function

	' Set the time part of a NotesDateTime From "HH:MM:SS ..."
	' Uses localized time separators; rounds off milliseconds
	Sub setXSDTime (ndt As NotesDateTime, xsdtime As String)
		If Not ndt.IsValidDate Then ndt.LocalTime = ""
		Dim dateonly As String
		dateonly = ndt.DateOnly	' preserve the date part
		Dim s As New notessession
		Dim intl As NotesInternational
		Set intl = s.International
	
		Dim timesep As String
		Let timesep = intl.TimeSep	
	
		ndt.LocalTime = dateonly & " " &_
		Left$(xsdtime,2) & timesep &_
		Mid$(xsdtime,4,2) & timesep &_
		Mid$(xsdtime,7,2)
	
	     'parse optional milliseconds
		If (Len(xsdtime) > 9 And Mid$(xsdtime, 9, 1) = ".") Then
			Dim milliseconds As Long
			milliseconds = 0
			Dim pos As Integer
			pos = 10
			While (pos<Len(xsdtime) And isDigit(Mid$(xsdtime, pos, 1)))
				pos = pos + 1
			Wend
			
			milliseconds = getMilliseconds(Mid$(xsdtime,10, pos-10))
			
	          'round up milliseconds for the current datetime
			If (milliseconds >= 500) Then
				ndt.AdjustSecond 1, True   'T: preserve DST semantics
			End If	
		End If	
	End Sub
	
	' Return the time info of a NotesDateTime as "HH:MM:SS"
	' Does not compute fractional seconds or timezone info.
	Function getXSDTime (ndt As NotesDateTime) As String
		If Not ndt.IsValidDate Then Error ErrTypeMismatch
		Dim vdatetime As Variant
		vdatetime = ndt.LSLocalTime
		getXSDTime = Format$(Hour(vdatetime),"00") & ":" &_
		Format$(Minute(vdatetime),"00") & ":" &_
		Format$(Second(vdatetime),"00")
	End Function
	
	' Return the time info of a NotesDateTime as "HH:MM:SS", adjusted for timezone
	' Does not compute fractional seconds.
	Function getXSDZoneTime (ndt As NotesDateTime) As String
		If Not ndt.IsValidDate Then Error ErrTypeMismatch
		Dim vdatetime As Variant
		Dim ndtCopy As New NotesDateTime(ndt.GMTTime)
		If (Abs(ndt.TimeZone) > 99) Then
			ndtCopy.AdjustHour(-1 * (ndt.TimeZone Mod 100))
			ndtCopy.AdjustMinute(-1 * (ndt.TimeZone/100))
		Else
			ndtCopy.AdjustHour(-1 * ndt.TimeZone)			
		End If
		If (ndt.IsDST) Then
			ndtCopy.AdjustHour(1)
		End If
		vdatetime = ndtCopy.LSGMTTime  'adjusted to the zone time
	
		getXSDZoneTime = Format$(Hour(vdatetime),"00") & ":" &_
		Format$(Minute(vdatetime),"00") & ":" &_
		Format$(Second(vdatetime),"00")
	End Function

	' Return the XSD zone part of a NotesDateTime as "Z" or "+HH:00" or "-HH:00"
	Function getXSDZone (ndt As NotesDateTime) As String
		If Not ndt.IsValidDate Then Error ErrTypeMismatch

		Dim ret As String
		Dim zone As Integer
		zone = ndt.TimeZone
		If ndt.IsDST Then
			zone = zone - 1
		End If
		zone = Abs(zone)
		If (zone) > 0 Then
			If zone > 99 Then  'MMHH
				Dim mins As Integer
				Dim hrs As Integer
				mins = zone/100
				hrs = zone Mod 100
				ret = Format$(hrs,"00") & ":" & Format$(mins,"00")
			Elseif zone > 9 Then  'HH
				ret = Cstr(zone) & ":00"
			Else  'H
				ret = "0" & Cstr(zone) & ":00"
			End If
			If (ndt.TimeZone < 0 Or (ndt.TimeZone = 0 And ndt.IsDST)) Then
				ret = "+" & ret   'XSD offsets are opposite of ndt
			Else
				ret = "-" & ret
			End If
		Else
			ret = "Z"
		End If
		getXSDZone = ret
	End Function

	' Set the date, time & zone parts of a NotesDateTime From "CCYY-MM-DDT...Z..."
	' If the zone offset is not supported by the NotesDateTime class, the NotesDateTime
	' zone properties are converted to GMT.
	Sub setXSDDateTime(ndt As NotesDateTime, source As String)
	   'based on lotus/domino/axis/encoding/ser/CalendarDeserializer:		
        'validate fixed portion of format
		
		Dim sourceLen As Integer
		sourceLen = Len(source)
		
		If Left$(source,1) = "+" Then
			source = Right$(source, sourceLen-1)   'drop the leading '+'
		End If
		
		If Left$(source,1) = "-" Then  'BC dates: can't represent them in NotesDateTime
			Error 4045, "Invalid date (" & source & ")" 'lsERR_NOTES_INVALID_DATE
		End If
		
		If (sourceLen < 19) Then
			Error 4045, "Invalid date (" & source & ")" 'lsERR_NOTES_INVALID_DATE
		End If
		
		If (Not Mid$(source, 5,1) = "-" Or Not Mid$(source,8,1) = "-" Or Not Mid$(source,11,1) = "T") Then
			Error 4045, "Invalid date (" & source & ")" 'lsERR_NOTES_INVALID_DATE
		End If
		
		If (Not Mid$(source, 14,1) = ":" Or Not Mid$(source,17,1) = ":" ) Then
			Error 4045, "Invalid date (" & source & ")" 'lsERR_NOTES_INVALID_DATE
		End If
		
         ' convert what we have validated so far
		Dim TmpDate As String		
		Dim s As New notessession
		
		Dim intl As NotesInternational
		Set intl = s.International
		
		
		Dim datesep As String
		Let datesep = intl.DateSep
		If (Intl.IsDateDMY) Then
			TmpDate = Mid$(source,9,2)   'Day
			TmpDate = TmpDate  & datesep &_
			Mid$(source,6,2)               'Month
			TmpDate = TmpDate & datesep &_
			Left$(source,4)                   'Year			
		Elseif (Intl.IsDateYMD) Then
			TmpDate = Left$(source,4)   'Year
			TmpDate = TmpDate  & datesep &_
			Mid$(source,6,2)               'Month
			TmpDate = TmpDate & datesep &_
			Mid$(source,9,2)                   'Day
		Else
			TmpDate = Mid$(source,6,2)   'Month
			TmpDate = TmpDate  & datesep &_
			Mid$(source,9,2)               'Day
			TmpDate = TmpDate & datesep &_
			Left$(source,4)                   'Year			
		End If
		
		'normalize to GMT for this machine's timezone, to prepare for applying any XSD timezone part, below
		Dim thiszoneoffset As Integer
		thiszoneoffset = intl.TimeZone   ' ndt.TimeZone   'default for this machine
		If (Intl.IsDST) Then
			thiszoneoffset = thiszoneoffset - 1
		End If
		
		Dim pos As Integer		
		pos = 20  
		
		Dim roundseconds As Integer
		Dim xsdzonehours As Long
		Dim xsdzonemins As Long
		roundseconds = 0		
		xsdzonehours = 0
		xsdzonemins = 0
		
          'parse optional milliseconds 
		If (pos < sourceLen And Mid$(source, pos, 1) = ".") Then
			Dim milliseconds As Long
			milliseconds = 0
			Dim start As Integer
			pos = pos + 1			
			start = pos
			While (pos<=sourceLen And isDigit(Mid$(source, pos, 1)))
				pos = pos + 1
			Wend
			
			milliseconds = getMilliseconds(Mid$(source,start,pos-start))
			
               'round up milliseconds for the current datetime
			If (milliseconds >= 500) Then
				roundseconds = 1		
			End If
		End If		
		
		Dim timesep As String
		Let timesep = intl.TimeSep
		TmpDate = TmpDate & " " & Mid$(source,12,2) & timesep & Mid$(source, 15, 2) & timesep & Mid$(source, 18,2)			
		
            'parse optional timezone
		If (pos+5 <= sourceLen And _
		(Mid$(source, pos,1) = "+" Or  Mid$(source,pos,1) ="-")) Then
			
			If ( Not isDigit(Mid$(source, pos+1,1)) Or _
			Not isDigit(Mid$(source, pos+2, 1)) Or _
			Not Mid$(source, pos+3, 1)  = ":"  Or _
			Not isDigit(Mid$(source, pos+4,1)) Or _
			Not isDigit(Mid$(source, pos+5,1))) Then
				Error 4045, "Invalid date (" & source & ")" 'lsERR_NOTES_INVALID_DATE
			End If
			xsdzonehours = Clng(Mid$(source, pos+1, 1))*10 + Clng(Mid$(source, pos+2, 1))
			xsdzonemins = Clng(Mid$(source, pos+4, 1))*10 + Clng(Mid$(source, pos+5, 1))			
			
               ' use zonehours to fetch canonical timezone for setting local time
			If Mid$(source, pos, 1) ="-" Then			
				xsdzonehours = -1 * xsdzonehours
				xsdzonemins = -1 * xsdzonemins
			End If
			pos = pos + 6
		End If
		
		Dim tmpNdt As New NotesDateTime("")
		If (pos = sourceLen And Mid$(source,pos,1) = "Z") Then
			tmpNdt.LocalTime = TmpDate  & " " & " GMT"		
			pos = pos + 1
		Else
			Dim zone As String
			If (xsdzonemins = 0) Then
				zone = getZone(xsdzonehours, 0)
				tmpNdt.LocalTime = TmpDate  & " " & zone
			Else
				Dim zone1 As String				
				zone1 = getZone(xsdzonehours, xsdzonemins)	
				If Len(zone1) > 0 Then
					tmpNdt.LocalTime = TmpDate  & " " & zone1					
				Else 'couldn't find a timezone abbrev NotesDateTime would recognize; just convertToZone GMT
					zone = getZone(xsdzonehours, 0)
					tmpNdt.LocalTime = TmpDate  & " " & zone					
					tmpNdt.AdjustMinute -1*xsdzonemins, True
					tmpNdt.ConvertToZone 0, False    'GMT
				End If
			End If	
		End If
		
		tmpNdt.AdjustSecond(roundseconds)
		
		If (pos < sourceLen) Then
			Exit Sub
		End If
		'success: set in/out value:
		Set ndt = tmpNdt
	End Sub

	Function isDigit(inp As String) As Boolean
		On Error Goto errhandler
		Dim i As Integer
		i = Cint(inp)
		If i > -1 And i < 10 Then
			isDigit = True
		Else
			isDigit = False
		End If
		Exit Function
	errhandler:
		isDigit = False
		Resume done
	done:
	End Function

	Function getZone(zoneoffset As Long, zonemins As Long) As String
		getZone = ""		
		Select Case Abs(zonemins)
		Case 30:
			Select Case zoneoffset
			Case 11: getZone = "ZE11B"	
			Case 10: getZone="ZE10B"
			Case 9: getZone="ZE9B"
			Case 6: getZone="ZE6B"
			Case 5: getZone="ZE5B"
			Case 4: getZone="ZE4B"				
			Case 3: getZone="ZE3B"					
			Case -3: getZone="NST"	
			Case -9: getZone="ZW9B"
			End Select
			
		Case 45:
			Select Case zoneoffset
			Case 12: getZone="ZE12C"
			Case 5: getZone="ZE5C"
			End Select
			
		Case 0:
			Select Case zoneoffset		
			Case 12: getZone = "ZE12"
			Case 11: getZone = "ZE11"
			Case 10: getZone = "ZE10"
			Case 9: getZone = "ZE9"
			Case 8: getZone = "ZE8"  
			Case 7: getZone = "ZE7"  
			Case 6: getZone = "ZE6"  
			Case 5: getZone = "ZE5"  
			Case 4: getZone = "ZE4"  
			Case 3: getZone = "ZE3"  
			Case 2: getZone = "ZE2"  
			Case 1: getZone = "CET" 
			Case 0: getZone = "GMT"
			Case -1: getZone = "ZW1"
			Case -2: getZone = "ZW2"
			Case -3: getZone = "ZW3"
			Case -4: getZone = "AST"
			Case -5: getZone = "EST"
			Case -6: getZone = "CST"
			Case -7: getZone = "MST"
			Case -8: getZone = "PST"
			Case -9: getZone = "YST"
			Case -10: getZone = "HST"
			Case -11: getZone = "BST"
			Case -12: getZone = "ZW12"	
			End Select
		End Select		
	End Function

	Function getMilliseconds(millisecondpart As String) As Long
		Dim milli As String
		milli = millisecondpart
		Dim milliLen As Integer
		milliLen = Len(millisecondpart)
		Dim milliseconds As Long
		milliseconds = 0
	
		If milliLen < 3 Then  'pad it out to 3 digits
			While (milliLen < 3)
				milli = milli & "0"
				milliLen = milliLen + 1
			Wend
		End If
		If Len(milli) = 3 Then
			milliseconds = Cint(milli)
		Else 'truncate and round off:
			milliseconds = Cint( Mid$(milli, 1,3))
			If Strcomp(Mid$(milli, 4,1), "4") > 0 Then
				milliseconds = milliseconds + 1
			End If
		End If
	
		getMilliseconds = milliseconds
	
	End Function

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' ROOT HOLDER CLASS
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS INOUT_HOLDER
END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' ROOT CLASS FOR LOTUSSCRIPT PROXY OBJECTS
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS LS_PROXY_OBJECT

    PRIVATE ValueAsString As String

	SUB setValueFromString (value As String)
		ValueAsString = value
	END SUB

	FUNCTION getValueAsString () As String
		getValueAsString = ValueAsString
	END FUNCTION

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' ROOT CLASS AND HOLDER FOR ANY AND ALL XML TYPES
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS XSD_ANYTYPE AS LS_PROXY_OBJECT
END CLASS

PUBLIC CLASS XSD_ANYTYPE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_ANYTYPE

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' BASE CLASS FOR ALL SIMPLE TYPES
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS XSD_SIMPLETYPE AS XSD_ANYTYPE
END CLASS

PUBLIC CLASS XSD_SIMPLETYPE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_SIMPLETYPE

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' ROOT CLASS AND HOLDER FOR LISTS OF SIMPLE TYPES.
'
' SUBCLASSES MUST DEFINE A 0-BASED ARRAY OF THE APPROPRIATE TYPE
' AS WELL AS OVERRIDE METHODS THAT ACCESS AND MODIFY THAT ARRAY:
'
'	SUB setListValueFromString (idx As INTEGER, value As STRING)
'	FUNCTION getListValueAsString (idx As INTEGER) As STRING
'	FUNCTION getListLength () As INTEGER
'
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS XSD_LIST AS XSD_SIMPLETYPE

	' Return a String with a space-separated concatentation
	' of all the non-null items in the list

	FUNCTION getValueAsString () As STRING
		IF ME.getListLength > 0 THEN
			DIM i As INTEGER
			DIM count As INTEGER
			FOR i = 0 TO ME.getListLength-1
				IF ME.getListValueAsString(i) <> "" THEN
					IF count > 0 THEN getValueAsString = getValueAsString & " "
					getValueAsString = getValueAsString & ME.getListValueAsString(i)
					count = count+1
				END IF
			NEXT i
		END IF
	END FUNCTION

	' SUBs and FUNCTIONs that must be overridden by each subclass

	SUB setListValueFromString (idx As INTEGER, value As STRING)
		ERROR ErrIllegalOperation
	END SUB

	FUNCTION getListValueAsString (idx As INTEGER) As STRING
		ERROR ErrIllegalOperation
	END FUNCTION

	FUNCTION getListLength () As INTEGER
		ERROR ErrIllegalOperation
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_LIST_HOLDER AS INOUT_HOLDER

	PUBLIC Value As XSD_LIST

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' SIMPLE TYPES AND HOLDERS
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS XSD_STRING AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_STRING_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_STRING

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_BOOLEAN AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_BOOLEAN_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_BOOLEAN

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_BASE64BINARY AS XSD_SIMPLETYPE

	SUB setValueFromNotesStream (nsValue As NotesStream)
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		CALL Me.setValueFromString (xdtc.notesStreamToBase64Ext (nsValue))
	END SUB

	FUNCTION getValueAsNotesStream () As NotesStream
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		set getValueAsNotesStream = xdtc.base64ToNotesStreamExt (Me.getValueAsString())
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_BASE64BINARY_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_BASE64BINARY

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_HEXBINARY AS XSD_SIMPLETYPE

	SUB setValueFromNotesStream (nsValue As NotesStream)
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		CALL Me.setValueFromString (xdtc.notesStreamToHexBinary (nsValue))
	END SUB

	FUNCTION getValueAsNotesStream () As NotesStream
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		set getValueAsNotesStream = xdtc.hexBinaryToNotesStream (Me.getValueAsString())
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_HEXBINARY_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_HEXBINARY

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_FLOAT AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_FLOAT_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_FLOAT

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_DECIMAL AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_DECIMAL_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_DECIMAL

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_DOUBLE AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_DOUBLE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_DOUBLE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_ANYURI AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_ANYURI_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_ANYURI

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_QNAME AS XSD_SIMPLETYPE

	PRIVATE NamespaceURI As STRING
	PRIVATE LocalPart As STRING
	PRIVATE Prefix As STRING

	SUB setNamespaceURI (value As STRING)
		NamespaceURI = value
	END SUB

	FUNCTION getNamespaceURI () As STRING
		getNamespaceURI = NamespaceURI
	END FUNCTION

	SUB setLocalPart (value As STRING)
		LocalPart = value
	END SUB

	FUNCTION getLocalPart () As STRING
		getLocalPart = LocalPart
	END FUNCTION

	SUB setPrefix (value As STRING)
		Prefix = value
	END SUB

	FUNCTION getPrefix () As STRING
		getPrefix = Prefix
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_QNAME_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_QNAME

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NOTATION AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_NOTATION_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NOTATION

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_DURATION AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_DURATION_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_DURATION

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_DATETIME AS XSD_SIMPLETYPE

	SUB SetValueFromNotesDateTime (value As NotesDateTime)  'deprecated
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		CALL ME.setValueFromString (xdtc.getXSDDate (value) & "T" & xdtc.getXSDTime (value))
	End SUB

	Sub SetValueWithZoneFromNotesDateTime (value As NotesDateTime)
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		Call Me.setValueFromString (xdtc.getXSDZoneDate (value) & "T" & xdtc.getXSDZoneTime (value) & xdtc.getXSDZone(value))
	End Sub

	Function GetValueAsNotesDateTime ( ) As NotesDateTime
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		Dim ndt As New NotesDateTime ("")
		If Mid$(Me.getValueAsString,11,1) = "T" Then	' if there's a time part after CCYY-MM-DD
			Call xdtc.setXSDDateTime (ndt, Me.getValueAsString)
		Else
			Call xdtc.setXSDDate (ndt, Me.getValueAsString)			
		End If
		set GetValueAsNotesDateTime = ndt
	End FUNCTION

END CLASS

PUBLIC CLASS XSD_DATETIME_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_DATETIME

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_TIME AS XSD_SIMPLETYPE

	SUB SetValueFromNotesDateTime (value As NotesDateTime)  'deprecated
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		CALL ME.setValueFromString (xdtc.getXSDTime (value))
	End SUB

	Sub SetValueWithZoneFromNotesDateTime (value As NotesDateTime)
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		Call Me.setValueFromString (xdtc.getXSDZoneTime (value) & xdtc.getXSDZone(value))
	End Sub	
	
	Function GetValueAsNotesDateTime ( ) As NotesDateTime
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		Dim ndt As New NotesDateTime ("")
		Call xdtc.setXSDTime (ndt, ME.getValueAsString)
		set GetValueAsNotesDateTime = ndt
	End FUNCTION

END CLASS

PUBLIC CLASS XSD_TIME_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_TIME

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_DATE AS XSD_SIMPLETYPE

	SUB SetValueFromNotesDateTime (value As NotesDateTime)  'deprecated
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		CALL ME.setValueFromString (xdtc.getXSDDate (value))
	End SUB

	Sub SetValueWithZoneFromNotesDateTime (value As NotesDateTime)
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		Call Me.setValueFromString (xdtc.getXSDZoneDate (value) & xdtc.getXSDZone(value))
	End Sub	

	Function GetValueAsNotesDateTime ( ) As NotesDateTime
		Dim xdtc As New XSD_DATATYPE_CONVERTER
		Dim ndt As New NotesDateTime ("")
		Call xdtc.setXSDDate (ndt, ME.getValueAsString)
		set GetValueAsNotesDateTime = ndt
	End FUNCTION

END CLASS

PUBLIC CLASS XSD_DATE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_DATE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_GYEARMONTH AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_GYEARMONTH_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_GYEARMONTH

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_GYEAR AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_GYEAR_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_GYEAR

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_GMONTHDAY AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_GMONTHDAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_GMONTHDAY

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_GDAY AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_GDAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_GDAY

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_GMONTH AS XSD_SIMPLETYPE
END CLASS

PUBLIC CLASS XSD_GMONTH_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_GMONTH

END CLASS


'--------------------------------------------------------------------
'--------------------------------------------------------------------
' TYPES DERIVED FROM XSD_STRING
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS XSD_NORMALIZEDSTRING AS XSD_STRING
END CLASS

PUBLIC CLASS XSD_NORMALIZEDSTRING_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NORMALIZEDSTRING

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_TOKEN AS XSD_NORMALIZEDSTRING
END CLASS

PUBLIC CLASS XSD_TOKEN_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_TOKEN

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_LANGUAGE AS XSD_TOKEN
END CLASS

PUBLIC CLASS XSD_LANGUAGE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_LANGUAGE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NAME AS XSD_TOKEN
END CLASS

PUBLIC CLASS XSD_NAME_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NAME

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NCNAME AS XSD_NAME
END CLASS

PUBLIC CLASS XSD_NCNAME_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NCNAME

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_ID AS XSD_NCNAME
END CLASS

PUBLIC CLASS XSD_ID_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_ID

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_IDREF AS XSD_NCNAME
END CLASS

PUBLIC CLASS XSD_IDREF_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_IDREF

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_IDREFS AS XSD_LIST

	PUBLIC theList () As XSD_IDREF
	PRIVATE initialized As BOOLEAN

	SUB initListItem (idx As INTEGER)
		if theList(idx) IS NOTHING THEN set theList(idx) = new XSD_IDREF
	END SUB

	SUB setListValueFromString (idx As INTEGER, value As STRING)
		IF idx < 0 THEN ERROR ErrArgOutOfRange
		IF NOT initialized THEN
			REDIM theList (0 TO idx)
			initialized = TRUE
		ELSE
			IF idx > UBOUND(theList) THEN REDIM PRESERVE theList (0 TO idx)
		END IF
		CALL initListItem(idx)
		CALL theList(idx).setValueFromString (value)
	END SUB

	FUNCTION getListValueAsString (idx As INTEGER) As STRING
		IF NOT initialized THEN ERROR ErrArgOutOfRange
		CALL initListItem(idx)
		getListValueAsString = theList(idx).getValueAsString
	END FUNCTION

	FUNCTION getListLength () As INTEGER
		IF NOT initialized THEN
			getListLength = 0
		ELSE
			getListLength = UBOUND(theList)+1
		END IF
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_IDREFS_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_IDREFS

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_ENTITY AS XSD_NCNAME
END CLASS

PUBLIC CLASS XSD_ENTITY_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_ENTITY

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_ENTITIES AS XSD_LIST

	PUBLIC theList () As XSD_ENTITY
	PRIVATE initialized As BOOLEAN

	SUB initListItem (idx As INTEGER)
		if theList(idx) IS NOTHING THEN set theList(idx) = new XSD_ENTITY
	END SUB

	SUB setListValueFromString (idx As INTEGER, value As STRING)
		IF idx < 0 THEN ERROR ErrArgOutOfRange
		IF NOT initialized THEN
			REDIM theList (0 TO idx)
			initialized = TRUE
		ELSE
			IF idx > UBOUND(theList) THEN REDIM PRESERVE theList (0 TO idx)
		END IF
		CALL initListItem(idx)
		CALL theList(idx).setValueFromString (value)
	END SUB

	FUNCTION getListValueAsString (idx As INTEGER) As STRING
		IF NOT initialized THEN ERROR ErrArgOutOfRange
		CALL initListItem(idx)
		getListValueAsString = theList(idx).getValueAsString
	END FUNCTION

	FUNCTION getListLength () As INTEGER
		IF NOT initialized THEN
			getListLength = 0
		ELSE
			getListLength = UBOUND(theList)+1
		END IF
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_ENTITIES_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_ENTITIES

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NMTOKEN AS XSD_TOKEN
END CLASS

PUBLIC CLASS XSD_NMTOKEN_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NMTOKEN

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NMTOKENS AS XSD_LIST

	PUBLIC theList () As XSD_NMTOKEN
	PRIVATE initialized As BOOLEAN

	SUB initListItem (idx As INTEGER)
		if theList(idx) IS NOTHING THEN set theList(idx) = new XSD_NMTOKEN
	END SUB

	SUB setListValueFromString (idx As INTEGER, value As STRING)
		IF idx < 0 THEN ERROR ErrArgOutOfRange
		IF NOT initialized THEN
			REDIM theList (0 TO idx)
			initialized = TRUE
		ELSE
			IF idx > UBOUND(theList) THEN REDIM PRESERVE theList (0 TO idx)
		END IF
		CALL initListItem(idx)
		CALL theList(idx).setValueFromString (value)
	END SUB

	FUNCTION getListValueAsString (idx As INTEGER) As STRING
		IF NOT initialized THEN ERROR ErrArgOutOfRange
		CALL initListItem(idx)
		getListValueAsString = theList(idx).getValueAsString
	END FUNCTION

	FUNCTION getListLength () As INTEGER
		IF NOT initialized THEN
			getListLength = 0
		ELSE
			getListLength = UBOUND(theList)+1
		END IF
	END FUNCTION

END CLASS

PUBLIC CLASS XSD_NMTOKENS_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NMTOKENS

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' TYPES DERIVED FROM XSD_DECIMAL
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS XSD_INTEGER AS XSD_DECIMAL
END CLASS

PUBLIC CLASS XSD_INTEGER_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_INTEGER

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NONPOSITIVEINTEGER AS XSD_INTEGER
END CLASS

PUBLIC CLASS XSD_NONPOSITIVEINTEGER_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NONPOSITIVEINTEGER

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NEGATIVEINTEGER AS XSD_NONPOSITIVEINTEGER
END CLASS

PUBLIC CLASS XSD_NEGATIVEINTEGER_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NEGATIVEINTEGER

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_LONG AS XSD_INTEGER
END CLASS

PUBLIC CLASS XSD_LONG_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_LONG

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_INT AS XSD_LONG
END CLASS

PUBLIC CLASS XSD_INT_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_INT

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_SHORT AS XSD_INT
END CLASS

PUBLIC CLASS XSD_SHORT_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_SHORT

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_BYTE AS XSD_SHORT
END CLASS

PUBLIC CLASS XSD_BYTE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_BYTE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_NONNEGATIVEINTEGER AS XSD_INTEGER
END CLASS

PUBLIC CLASS XSD_NONNEGATIVEINTEGER_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_NONNEGATIVEINTEGER

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_UNSIGNEDLONG AS XSD_NONNEGATIVEINTEGER
END CLASS

PUBLIC CLASS XSD_UNSIGNEDLONG_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_UNSIGNEDLONG

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_UNSIGNEDINT AS XSD_UNSIGNEDLONG
END CLASS

PUBLIC CLASS XSD_UNSIGNEDINT_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_UNSIGNEDINT

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_UNSIGNEDSHORT AS XSD_UNSIGNEDINT
END CLASS

PUBLIC CLASS XSD_UNSIGNEDSHORT_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_UNSIGNEDSHORT

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_UNSIGNEDBYTE AS XSD_UNSIGNEDSHORT
END CLASS

PUBLIC CLASS XSD_UNSIGNEDBYTE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_UNSIGNEDBYTE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS XSD_POSITIVEINTEGER AS XSD_NONNEGATIVEINTEGER
END CLASS

PUBLIC CLASS XSD_POSITIVEINTEGER_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS XSD_POSITIVEINTEGER

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' HOLDER TYPES FOR LOTUSSCRIPT BUILT-IN TYPES
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS BOOLEAN_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS BOOLEAN

END CLASS

PUBLIC CLASS BOOLEANARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS BOOLEAN

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS BYTE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS BYTE

END CLASS

PUBLIC CLASS BYTEARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS BYTE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS CURRENCY_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS CURRENCY

END CLASS

PUBLIC CLASS CURRENCYARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS CURRENCY

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS DOUBLE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS DOUBLE

END CLASS

PUBLIC CLASS DOUBLEARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS DOUBLE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS INTEGER_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS INTEGER

END CLASS

PUBLIC CLASS INTEGERARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS INTEGER

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS LONG_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS LONG

END CLASS

PUBLIC CLASS LONGARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS LONG

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS SINGLE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS SINGLE

END CLASS

PUBLIC CLASS SINGLEARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS SINGLE

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS STRING_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS STRING

END CLASS

PUBLIC CLASS STRINGARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS STRING

END CLASS

'--------------------------------------------------------------------

PUBLIC CLASS VARIANT_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS VARIANT

END CLASS

PUBLIC CLASS VARIANTARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS VARIANT

END CLASS

'--------------------------------------------------------------------
'--------------------------------------------------------------------
' HOLDER TYPES FOR LOTUSSCRIPT BACKEND CLASSES
'--------------------------------------------------------------------
'--------------------------------------------------------------------
PUBLIC CLASS NOTESDOMELEMENTNODE_HOLDER AS INOUT_HOLDER

	PUBLIC Value AS NOTESDOMELEMENTNODE

END CLASS

PUBLIC CLASS NOTESDOMELEMENTNODEARRAY_HOLDER AS INOUT_HOLDER

	PUBLIC Value() AS NOTESDOMELEMENTNODE

END CLASS


'--------------------------------------------------------------------
'--------------------------------------------------------------------
' ROOT FAULT CLASS
'--------------------------------------------------------------------
'--------------------------------------------------------------------

PUBLIC CLASS WS_FAULT

	PRIVATE Fault As BOOLEAN
	PRIVATE FaultString As STRING
	PRIVATE FaultCode As STRING
	PRIVATE FaultActor As STRING
	PRIVATE FaultDetails() As NOTESDOMELEMENTNODE

	SUB setFault (value As BOOLEAN)
		Fault = value
	END SUB

	FUNCTION getFault () As BOOLEAN
		getFault = Fault
	END FUNCTION

	SUB setFaultString (value As STRING)
		FaultString = value
	END SUB

	FUNCTION getFaultString () As STRING
		getFaultString = FaultString
	END FUNCTION

	SUB setFaultCode (value As STRING)
		FaultCode = value
	END SUB

	FUNCTION getFaultCode () As STRING
		Dim ret As String
		' remove any namespace prefix		
		ret = Strright(FaultCode, ":")
		If Len(ret) < 1 Then
			ret = FaultCode
		End If
		getFaultCode = ret	
	END FUNCTION

	SUB setFaultActor (value As STRING)
		FaultActor = value
	END SUB

	FUNCTION getFaultActor () As STRING
		getFaultActor = FaultActor
	END FUNCTION

	SUB setFaultDetails (value() As NOTESDOMELEMENTNODE)
		On Error GoTo NoOp
		Dim l as Integer
		Dim u as Integer
		l = LBound(value)
		u = UBound(value)
		ReDim FaultDetails(l to u) as NOTESDOMELEMENTNODE
		While (l <= u)
			Set FaultDetails(l) = value(l)
			l = l + 1
		Wend
		Exit Sub
NoOp:
	END SUB

	FUNCTION getFaultDetails () As NOTESDOMELEMENTNODEARRAY_HOLDER
		On Error GoTo NoOp
		Dim AH as New NOTESDOMELEMENTNODEARRAY_HOLDER
		Dim l as Integer
		Dim u as Integer
		l = LBound(FaultDetails)
		u = UBound(FaultDetails)
		ReDim AH.value(l to u) as NOTESDOMELEMENTNODE
		While (l <= u)
			Set AH.value(l) = FaultDetails(l)
			l = l + 1
		Wend
		Set getFaultDetails = AH
		Exit Function
NoOp:
	END FUNCTION

	SUB NEW
		ReDim FaultDetails(0) As NOTESDOMELEMENTNODE 'guarantee a Nothing element
	END SUB

END CLASS

'-----------------------------------------------------------------------------
'-----------------------------------------------------------------------------
' BASE TYPE FOR WEB SERVICE ENABLED LOTUSSCRIPT SCRIPT LIBRARY PORTTYPE CLASS
'-----------------------------------------------------------------------------
'-----------------------------------------------------------------------------
%If WEB_SERVICE_CONSUMER_SCRIPTLIB
Public Class PortTypeBase

	Private Service as NotesWebServiceEngine
	Private NoFault as WS_FAULT

	Public Sub New()
		set Service = new NotesWebServiceEngine
		set NoFault = new WS_FAULT
	End Sub

	Public Sub SetEndpoint(url as String)
		call Service.SetEndpoint(url)
	End Sub

	Public Function GetEndpoint() As String
		GetEndpoint = Service.GetEndpoint()
	End Function

	Public Function GetLastFault() As WS_FAULT
		Set GetLastFault = Service.GetLastFault
		if (GetLastFault is nothing) then
			set GetLastFault = NoFault
		End if
	End Function

	Public Sub SetTimeout(ms as Long)
		call Service.SetTimeout(ms)
	End Sub

	Public Function GetTimeout() As Long
		GetTimeout = Service.GetTimeout()
	End Function

	Public Sub SetCredentials(username As String, password As String)
		call Service.SetCredentials(username, password)
	End Sub

	Public Sub SetSSLOptions(Opt as Long)
		call Service.SetSSLOptions(Opt)
	End Sub

	Public Function GetSSLOptions() As Long
		GetSSLOptions = Service.GetSSLOptions()
	End Function

End Class
%End If

Public Const NOTES_SSL_LOCATION				= 0

' SSL Options - To combine options add values
Public Const NOTES_SSL_ACCEPT_SITE_CERTS 	= 1
Public Const NOTES_SSL_ACCEPT_EXPIRED_CERTS	= 2
Public Const NOTES_SSL_SEND_CLIENT_CERT		= 4

' SSL Version - Select one
Public Const NOTES_SSL_V20_ONLY				= 1 + 65536
Public Const NOTES_SSL_V30_HELLO			= 2 + 65536
Public Const NOTES_SSL_V30_ONLY				= 3 + 65536
Public Const NOTES_SSL_V30_WITH_V20_HELLO	= 4 + 65536
Public Const NOTES_SSL_NEGOTIATED			= 5 + 65536