Subversion Repositories DevTools

<%

'=============================================================

'//

'//						SortHelper

'//

'// version: 		1.2

'//	last modified: 	11 Jul 2005 15:20 by Sasha Vukovic

'=============================================================

%>

<%

'--------------- Global Constants ----------------

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

Class SortHelper

	Private enumVERSION_SORT

	Private enumSTRING_SORT

	Private m_SortType

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

	Private Sub SwapRows(ary,row1,row2)

		'== This proc swaps two rows of an array 

		Dim x,tempvar

		For x = 0 to Ubound(ary,1)

			tempvar = ary(x,row1)    

			ary(x,row1) = ary(x,row2)

			ary(x,row2) = tempvar

		Next

	End Sub

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

	Private Sub QuickSort( ByRef vec,loBound,hiBound,SortField)

		'==--------------------------------------------------------==

		'== Sort a 2 dimensional array on SortField                ==

		'==                                                        ==

		'== This procedure is adapted from the algorithm given in: ==

		'==    ~ Data Abstractions & Structures using C++ by ~     ==

		'==    ~ Mark Headington and David Riley, pg. 586    ~     ==

		'== Quicksort is the fastest array sorting routine for     ==

		'== unordered arrays.  Its big O is  n log n               ==

		'==                                                        ==

		'== Parameters:                                            ==

		'== vec       - array to be sorted                         ==

		'== SortField - The field to sort on (2nd dimension value) ==

		'== loBound and hiBound are simply the upper and lower     ==

		'==   bounds of the array's 1st dimension.  It's probably  ==

		'==   easiest to use the LBound and UBound functions to    ==

		'==   set these.                                           ==

		'==--------------------------------------------------------==

		Dim pivot(),loSwap,hiSwap,temp,counter

		Redim pivot (Ubound(vec,1))

		'== Two items to sort

		if hiBound - loBound = 1 then

			if IsGreater( vec(SortField,loBound), vec(SortField,hiBound) ) then Call SwapRows(vec,hiBound,loBound)

		End If

		'== Three or more items to sort

		For counter = 0 to Ubound(vec,1)

			pivot(counter) = vec(counter,int((loBound + hiBound) / 2))

			vec(counter,int((loBound + hiBound) / 2)) = vec(counter,loBound)

			vec(counter,loBound) = pivot(counter)

		Next

		loSwap = loBound + 1

		hiSwap = hiBound

		do

			'== Find the right loSwap

			while loSwap < hiSwap and ( NOT IsGreater( vec(SortField,loSwap), pivot(SortField) ) )

				loSwap = loSwap + 1

			wend

			'== Find the right hiSwap

			while IsGreater ( vec(SortField,hiSwap), pivot(SortField) )

			hiSwap = hiSwap - 1

			wend

			'== Swap values if loSwap is less then hiSwap

			if loSwap < hiSwap then Call SwapRows(vec,loSwap,hiSwap)

		loop while loSwap < hiSwap

		For counter = 0 to Ubound(vec,1)

			vec(counter,loBound) = vec(counter,hiSwap)

			vec(counter,hiSwap) = pivot(counter)

		Next

		'== Recursively call function .. the beauty of Quicksort

		'== 2 or more items in first section

		if loBound < (hiSwap - 1) then Call QuickSort(vec,loBound,hiSwap-1,SortField)

		'== 2 or more items in second section

		if hiSwap + 1 < hibound then Call QuickSort(vec,hiSwap+1,hiBound,SortField)

	End Sub

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

	Private Function IsGreater( ByRef sStringA, ByRef sStringB )

		Select Case m_SortType

			Case enumVERSION_SORT

				IsGreater = IsGreaterForVersionSort( sStringA, sStringB )

			Case enumSTRING_SORT

				IsGreater = IsGreaterForStringSort( sStringA, sStringB )

		End Select

	End Function

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

	Private Function IsGreaterForStringSort( ByRef sStringA, ByRef sStringB )

		IsGreaterForStringSort = Eval( sStringA > sStringB )

	End Function

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

	Private Function IsGreaterForVersionSort( ByVal sStringA, ByVal sStringB )

		Dim nMinLen, i, aCharsA, aCharsB, valA, valB

		Dim DoLengthComparison

		Const SEPARATOR = "."

		IsGreaterForVersionSort = FALSE

		DoLengthComparison = TRUE

		' Replace other delimmiting symbols with dot

		' This is used to sort version numbers.

		sStringA = Replace( sStringA, "-", SEPARATOR) 

		sStringB = Replace( sStringB, "-", SEPARATOR) 

		sStringA = Replace( sStringA, "_", SEPARATOR) 

		sStringB = Replace( sStringB, "_", SEPARATOR) 

		' Split version string with dot separator

		aCharsA = Split(sStringA, SEPARATOR)

		aCharsB = Split(sStringB, SEPARATOR)

		' Find which Ubound is smallest

		nMinLen = UBound(aCharsA)

		If nMinLen > UBound(aCharsB) Then nMinLen = UBound(aCharsB)

		'Response.write "======================================================<br>"

		'Response.write sStringA &" is greater then "& sStringB  &"<br>"

		' Content Comparison

		For i = 0 To nMinLen

			valA = aCharsA(i)

			valB = aCharsB(i)

			If IsNumeric(valA)  AND  IsNumeric(valB) Then 

				'Response.write valA &"IS NUMERIC"& valB &"<br>"

				' Do number compare

				valA = CDbl(valA)

				valB = CDbl(valB)

				If valA <> valB Then

					DoLengthComparison = FALSE

					If valA > valB Then

						IsGreaterForVersionSort = TRUE

						Exit For

					Else

						Exit For

					End If

				End If

			Else

				' Do string compare

				If valA <> valB Then

					DoLengthComparison = FALSE

					If valA > valB Then

						IsGreaterForVersionSort = TRUE

						Exit For

					Else

						Exit For

					End If

				End If

			End If

		Next

		' Continue with Lenght Comparison if required

		If DoLengthComparison AND ( Len(sStringA) > Len(sStringB) ) Then

			'Response.write "LENGTH COMPARISON<br>"

			IsGreaterForVersionSort = TRUE

		End If

		'Response.write "RESULT is greater:"& IsGreaterForVersionSort  &"<br>"

	End Function	

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

	Public Sub VersionSort( ByRef vec, loBound, hiBound, SortField )

		' Set default comparison implementation

		m_SortType = enumVERSION_SORT

		If hiBound >= 1 Then

			' Run sorting

			Call QuickSort( vec, loBound, hiBound, SortField)

		End If

	End Sub

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

	Public Sub StringSort( ByRef vec, loBound, hiBound, SortField )

		' Set default comparison implementation

		m_SortType = enumSTRING_SORT

		If hiBound >= 1 Then

			' Run sorting

			Call QuickSort( vec, loBound, hiBound, SortField)

		End If

	End Sub

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

	Private Sub Class_Initialize()

		' Set enums

		enumVERSION_SORT = 1

		enumSTRING_SORT = 2

	End Sub

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

	Private Sub Class_Terminate()

	End Sub

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

End Class

%>