source: Include/Classes/System/Collections/ArrayList.ab@ 141

' 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 ArrrayList()
        data.ArrayList(16)
    End Sub
/*
    Sub ArrayList(ByRef c As ICollection)
        ' 未実装
        Debug
    End Sub
*/
    Sub ArrayList(c As Long)
        data.ArrayList_Element(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

    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 = 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(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 ~ArrayList_Element()
        free(Elm)
    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