1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use std::fmt;

use super::TableEntity;

// class DataCollectionIterator<E extends TableEntity> implements Iterator<E> {
//   let DataCollectionBase<E> iterable;
//   let i64 length;
//   i64 index;
//   E current;

//   DataCollectionIterator(DataCollectionBase<E> iterable)
//       : iterable = iterable,
//         length = iterable.length,
//         index = 0;

//   E get current => current;

//   bool moveNext() {
//     i64 length = iterable.length;
//     if (length != length) {
//       throw ConcurrentModificationError(iterable);
//     }
//     if (index >= length) {
//       current = null;
//       return false;
//     }
//     current = iterable.elementAt(index);
//     index++;
//     return true;
//   }
// }

trait DataCollectionBase<E>
where
    E: TableEntity,
{
    fn release_items(&self, start: i64, end: i64);

    fn update_items(&self, start: i64);

    // fn get_iterator() -> Iterator<E> => DataCollectionIterator<E>(this);

    // fn first() -> E  => base.first;

    // fn last() -> E => base.last;

    // fn single() -> E => base.single;

    // fn get_length() -> usize => base.length;

    // fn set length(&self, i64 value);

    // E operator [](i64 index) => base[index];

    // operator []=(i64 index, E value) {
    //   // TODO: implement.
    //   throw UnimplementedError();
    // }

    fn add(&self, value: E);

    // fn add_all(&self, iterable: Iterator<E>);

    // fn elementAt(&self, i64 index) -> E;

    fn insert(&self, index: i64, value: E);

    // fn insert_all(&self, index: i64, iterable: Iterable<E>);

    fn remove(&self, element: E) -> bool;

    fn clear(&self);

    fn remove_at(&self, index: i64) -> E;

    fn remove_last(&self) -> E;

    fn remove_range(&self, start: i64, end: i64);
}