' Classes/System/Collections/ArrayList.ab

#require <Classes/System/Collections/misc.ab>

Class ArrayList
	Inherits IList /*, ICollection, IEnumerable, ICloneable*/
Public
	' --------------------------------
	' Properties
	/*Const*/ Virtual Function Capacity() As Long
		Return data.Capacity
	End Function

	Virtual Sub Capacity(c As Long)
		If c <> data.Capacity Then
			If c < data.Size Then
				'Throw ArgumentOutOfRangeException
				Debug
			Else
				reallocBuffer(c)
			End If
		End If
	End Sub

	/*Const*/ /*Override*/ Virtual Function Count() As Long
		Return data.Size
	End Function

	/*Const*/ Override Function IsFixedSize() As Boolean
		Return False
	End Function

	/*Const*/ Override Function IsReadOnly() As Boolean
		Return False
	End Function

	/*Const*/ /*Override*/ Virtual Function IsSynchronized() As Boolean
		Return False
	End Function
	' SyncRoot

	' Operators
	/*Const*/ /*Override*/ Virtual Function Operator [](i As Long) As *Object
		If 0 <= i And i < data.Size Then
			Return data.Elm[i]
		Else
			'Throw OutOfRangeException?
			Debug
		End If
	End Function
	
	/*Override*/ Virtual Sub Operator []=(i As Long, x As *Object)
		If 0 <= i And i < data.Size Then
			data.Elm[i] = 0
		Else
			'Throw OutOfRangeException?
			Debug
		End If
	End Sub

	' --------------------------------
	' Methods
	'   Constractors
	Sub ArrayList()
		data.Init(16)
	End Sub
/*
	Sub ArrayList(ByRef c As ICollection)
		' –¢ŽÀ‘•
		Debug
	End Sub
*/
	Sub ArrayList(c As Long)
		data.Init(c)
	End Sub

	'   Destractor
	Virtual Sub ~ArrayList()
	End Sub

'	Sub Operator =(ByRef a As ArrayList)

	/*Override*/ Virtual Function Add(x As *Object) As Long
		setLeastCapacity(data.Size + 1)
		data.Elm[data.Size] = x
		Add = data.Size
		data.Size++
	End Function

	/*Override*/ Virtual Function Add(x As Object) As Long
		setLeastCapacity(data.Size + 1)
		data.Elm[data.Size] = VarPtr(x)
		Add = data.Size
		data.Size++
	End Function

	Virtual Sub AddRange(ByRef c As ICollection)
		' TODO: ŽÀ‘•
	End Sub

	Const Virtual Function BinarySearch(x As *Object)
		' TODO: ŽÀ‘•
	End Function

	Const Virtual Function BinarySearch(x As *Object, ByRef c As IComparer) As Long
		' TODO: ŽÀ‘•
	End Function

	Const Virtual Function BinarySearch(index As Long, count As Long, x As *Object, ByRef c As IComparer) As Long
		' TODO: ŽÀ‘•
	End Function

	/*Override*/ Virtual Sub Clear()
		data.Size = 0
	End Sub

	Virtual Function Clone() As *ArrayList
		Dim p As *ArrayList
		p = New ArrayList(data.Size)
		p->data.Size = data.Size
		memcpy(p->data.Elm, This.data.Elm, SizeOf (*Object) * data.Size)
		Return p
	End Function

	/*Const*/ /*Override*/ /*Virtual Function Contains(x As *Object) As Boolean
		Dim i As Long
		For i = 0 To ELM(data.Size)
			If x->Equals(data.Elm[i]) Then
				Return True
			End If
		Next
	End Function*/

	' CopyTo
	/*Const*/ /*Override*/ Virtual Function GetEnumerator() As *IEnumerator
		'Return GetEnumerator(index, count)
	End Function

	Const Virtual Function GetEnumerator(index As Long, count As Long) As *IEnumerator
		' TODO: ŽÀ‘•
	End Function

	Virtual Function GetRange(index As Long, count As Long) As *ArrayList
		' TODO: ŽÀ‘•
	End Function

	/*Const*/ Override Function IndexOf(x As *Object) As Long
		Return IndexOf(x, 0, data.Size)
	End Function

	/*Const*/ Virtual Function IndexOf(x As *Object, startIndex As Long) As Long
		Return IndexOf(x, startIndex, data.Size - startIndex)
	End Function

	/*Const*/ Virtual Function IndexOf(x As *Object, startIndex As Long, count As Long) As Long
		Dim i As Long
		Dim last = Math.Min(startIndex + count - 1, data.Size)
		For i = startIndex To last
			If x->Equals(ByVal data.Elm[i]) Then
				Return i
			End If
		Next
	End Function

	Override Sub Insert(i As Long, x As *Object)
		setLeastCapacity(data.Size + 1)
		memmove(VarPtr(data.Elm[i + 1]), VarPtr(data.Elm[i]), SizeOf (*Object) * (data.Size - i))
		data.Elm[i] = x
		data.Size++
	End Sub

	Virtual Sub InsertRange(index As Long, ByRef c As ICollection)
		' TODO: ŽÀ‘•
	End Sub

	/*Const*/ Virtual Function LastIndexOf(x As *Object) As Long
		LastIndexOf(x, 0, data.Size)
	End Function

	/*Const*/ Virtual Function LastIndexOf(x As *Object, startIndex As Long) As Long
		Return LastIndexOf(x, startIndex, data.Size - startIndex)
	End Function

	/*Const*/ Virtual Function LastIndexOf(x As *Object, startIndex As Long, count As Long) As Long
		' TODO: ŽÀ‘•
	End Function

	Override Sub Remove(x As *Object)
		Dim i = IndexOf(x)
		If i > 0 Then
			RemoveAt(i)
		End If
	End Sub

	Override Sub RemoveAt(i As Long)
		RemoveRange(i, 1)
	End Sub
	
	Virtual Sub RemoveRange(i As Long, count As Long)
		Dim removeLastPos = i + count
		memmove(VarPtr(data.Elm[i]), VarPtr(data.Elm[removeLastPos]), SizeOf (*Object) * (data.Size - removeLastPos))
	End Sub

	Virtual Sub Reverse()
		Reverse(0, data.Size)
	End Sub

	Virtual Sub Reverse(startIndex As Long, count As Long)
		' TODO: ŽÀ‘•
	End Sub

	Virtual Sub SetRange(index As Long, ByRef c As ICollection)
		' TODO: ŽÀ‘•
	End Sub

	Virtual Sub Sort()
		' TODO: ŽÀ‘•
	End Sub

	Virtual Sub Sort(ByRef c As IComparer)
		Sort(0, data.Size, c)
	End Sub

	Virtual Sub Sort(index As Long, count As Long, ByRef c As IComparer)
		' TODO: ŽÀ‘•
	End Sub

	' ToArray
	Virtual Sub TrimToSize()
		reallocBuffer(data.Size)
	End Sub

	/*Override*/ Virtual Function ToString() As String
		Return "System.Collections.ArrayList"
	End Function

	' --------------------------------
	' static methods
	Static Function Adapter(ByRef l As IList) As *ArrayList
		' TODO: ŽÀ‘•
	End Function

	Static Function FixedSize(ByRef l As ArrayList) As *ArrayList
		' TODO: ŽÀ‘•
	End Function

	Static Function FixedSize(ByRef l As IList) As *IList
		Return FixedSize(Adapter(VarPtr(i)))
	End Function

	Static Function ReadOnly(ByRef l As ArrayList) As *ArrayList
		' TODO: ŽÀ‘•
	End Function

	Static Function ReadOnly(ByRef l As IList) As *IList
		Return ReadOnly(Adapter(VarPtr(i)))
	End Function

	Static Function Repeat(ByRef x As Object, c As Long) As *ArrayList
		Repeat = New ArrayList(c)
		Dim i As Long
		For i = 0 To ELM(c)
			Repeat->Add(VarPtr(x))
		Next
	End Function

	Static Function Synchronized(ByRef l As ArrayList) As *ArrayList
		' TODO: ŽÀ‘•
	End Function

	Static Function Synchronized(ByRef l As IList) As *IList
		Return Synchronized(Adapter(VarPtr(i)))
	End Function

Private
	Sub setLeastCapacity(c As Long)
		If data.Capacity < c Then
			reallocBuffer(c)
		End If
	End Sub

	Sub reallocBuffer(c As Long)
		Dim newBuf As ArrayList_Element(c)
		newBuf.Size = data.Size
		memcpy(newBuf.Elm, data.Elm, SizeOf (*Object) * newBuf.Size)
		newBuf.Swap(data)
	End Sub

	data As ArrayList_Element
End Class

Class ArrayList_Element
Public
	Sub ArrayList_Element()
		Init(0)
	End Sub
	Sub ArrayList_Element(c As Long)
		Init(c)
	End Sub

	Sub ~ArrayList_Element()
		free(Elm)
	End Sub

	Sub Init(c As Long)
		If c > 0 Then
			Elm = malloc(SizeOf (*Object) * c)
			If Elm = 0 Then
				' OutOfMemoryException
				Debug
			End If
		Else
			Elm = 0
		End If
		Size = 0
		Capacity = c
	End Sub

	Sub Swap(ByRef x As ArrayList_Element)
		Dim tmpElm = x.Elm
		x.Elm = This.Elm
		This.Elm = tmpElm

		Dim tmpSize = x.Size
		x.Size = This.Size
		This.Size = x.Size

		Dim tmpCap = x.Capacity
		x.Capacity = This.Capacity
		This.Capacity = tmpCap
	End Sub

	Elm As **Object
	Size As Long
	Capacity As Long
End Class