dataflow/
row.rs

1use super::TableEntity;
2
3pub struct DataRow<T> {
4    index: i64,
5    // table: DataTable,
6    /// The list that stores the actual data.
7    cells: Vec<T>,
8}
9
10impl<T> TableEntity for DataRow<T> {}
11
12impl<T> DataRow<T> {
13    /// Converts a column index or name to an index.
14    fn to_index(&self, column_index_or_name: i64) -> i64 {
15        // if (columnIndexOrName is int) return columnIndexOrName;
16        // return table.columnIndexByName[columnIndexOrName];
17        unimplemented!()
18    }
19
20    // /// Creates a new [DataRow] from a list of values.
21    // ///
22    // ///  Each value in [values] corresponds to a column. If [values] is too short,
23    // /// the remaining columns are filled with `null`.
24    // DataRow.internal(DataTable table, List values) {
25    //   table = table;
26    //   let n = table.columns.length;
27    //   let m = values.length;
28    //   let min = m;
29    //   if (min > n) min = n;
30    //   cells = values.sublist(0, min);
31    //   for (let i = min; i < n; i++) {
32    //     cells.add(null);
33    //   }
34    // }
35
36    // /// Returns the value of the column specified by [columnIndexOrName].
37    // operator [](columnIndexOrName) => cells[_toIndex(columnIndexOrName)];
38
39    // /// Sets the value of the column specified by [columnIndexOrName].
40    // operator []=(columnIndexOrName, value) {
41    //   let columnIndex = toIndex(columnIndexOrName);
42    //   let oldValue = cells[columnIndex];
43    //   cells[columnIndex] = value;
44    //   table.onCellChanged(index, columnIndex, oldValue, value);
45    // }
46
47    // /// Creates a [List] containing all cells in this [DataRow].
48    // List toList({bool growable: true}) => cells.toList(growable: growable);
49}
50
51// pub struct DataRowCollection<M, D> {
52//     base: Vec<DataRow<D>>,
53//     //     table: DataTable,
54// }
55
56// impl<M, D> DataRowCollection<M, D> {
57//     pub fn new(table: &DataTable<M, D>) -> Self {
58//         //   table = table;
59//         Self {
60//             base: Default::default(),
61//         }
62//     }
63// }
64
65// impl<M, D> DataCollectionBase<DataRow<D>> for DataRowCollection<M, D> {
66//     fn release_items(&self, start: i64, end: i64) {
67//         // while (start < end) {
68//         //   base[start].table = null;
69//         //   start++;
70//         // }
71//         unimplemented!()
72//     }
73
74//     fn update_items(&self, start: i64) {
75//         // let len = length;
76//         // while (start < len) {
77//         //   base[start]
78//         //     ..table = table
79//         //     ..index = start++;
80//         // }
81//         unimplemented!()
82//     }
83
84//     // @override
85//     // Iterator<E> get iterator => DataCollectionIterator<E>(this);
86
87//     // @override
88//     // E get first => base.first;
89
90//     // @override
91//     // E get last => base.last;
92
93//     // @override
94//     // E get single => base.single;
95
96//     // @override
97//     // i64 get length => base.length;
98
99//     // fn set length(&self, i64 value) {
100//     //   // TODO: implement.
101//     //   throw UnimplementedError();
102//     // }
103
104//     // @override
105//     // E operator [](i64 index) => base[index];
106
107//     // @override
108//     // operator []=(i64 index, E value) {
109//     //   // TODO: implement.
110//     //   throw UnimplementedError();
111//     // }
112
113//     fn add(&self, value: DataRow<D>) {
114//         // let index = length;
115//         // base.add(value);
116//         // updateItems(index);
117//         // table.onRowsOrColumnsInserted(this, index, 1);
118//         unimplemented!()
119//     }
120
121//     // fn add_all(&self, iterable: Iterator<E>) {
122//     // //     // let index = length;
123//     // //     // base.addAll(iterable);
124//     // //     // updateItems(index);
125//     // //     // table.onRowsOrColumnsInserted(this, index, iterable.length);
126//     // }
127
128//     // @override
129//     // E elementAt(&self, i64 index) => base[index];
130
131//     fn insert(&self, index: i64, value: DataRow<D>) {
132//         // base.insert(index, value);
133//         // updateItems(index);
134//         // table.onRowsOrColumnsInserted(this, index, 1);
135//         unimplemented!()
136//     }
137
138//     // fn insert_all(&self, index: i64, iterable: Iterable<E>) {
139//     //     // base.insertAll(index, iterable);
140//     //     // updateItems(index);
141//     //     // table.onRowsOrColumnsInserted(this, index, iterable.length);
142//     // }
143
144//     fn remove(&self, element: DataRow<D>) -> bool {
145//         // let index = base.indexOf(element);
146//         // if (index == -1) return false;
147//         // removeAt(index);
148//         // return true;
149//         unimplemented!()
150//     }
151
152//     fn clear(&self) {
153//         // let len = length;
154//         // if (len == 0) return;
155//         // releaseItems(0, len);
156//         // base.clear();
157//         // table.onRowsOrColumnsRemoved(this, 0, len);
158//         unimplemented!()
159//     }
160
161//     fn remove_at(&self, index: i64) -> DataRow<D> {
162//         // let e = base.removeAt(index);
163//         // e.table = null;
164//         // updateItems(index);
165//         // table.onRowsOrColumnsRemoved(this, index, 1);
166//         // return e;
167//         unimplemented!()
168//     }
169
170//     fn remove_last(&self) -> DataRow<D> {
171//         // let e = base.removeLast();
172//         // e.table = null;
173//         // table.onRowsOrColumnsRemoved(this, length, 1);
174//         // return e;
175//         unimplemented!()
176//     }
177
178//     fn remove_range(&self, start: i64, end: i64) {
179//         // releaseItems(start, end);
180//         // base.remove_range(start, end);
181//         // updateItems(start);
182//         // table.onRowsOrColumnsRemoved(this, start, end - start);
183//         unimplemented!()
184//     }
185
186//     // FIXME: bellow implementation
187
188//     // DataRow toDataRow(value) =>
189//     //     value is DataRow ? value : DataRow.internal(table, value);
190
191//     // DataRowCollection(DataTable table) : super(table);
192
193//     // /// Adds [value] to this collection.
194//     // ///
195//     // /// [value] can be a [DataRow] or a [List].
196//     // fn add(value: E) {
197//     //     // self.base.add(toDataRow(value));
198//     // }
199
200//     // /// Adds all elements of [iterable] to this collection.
201//     // ///
202//     // /// Each element in [iterable] can be a [DataRow] or a [List].
203//     // fn addAll(iterable: Iterable) {
204//     //     // self.base.addAll(iterable.map(toDataRow));
205//     // }
206
207//     // /// Inserts [value] at position [index] in this collection.
208//     // ///
209//     // /// [value] can be a [DataRow] or a [List].
210//     // fn insert(index: i64, value: E) {
211//     //     // self.base.insert(index, toDataRow(value));
212//     // }
213
214//     // /// Inserts all elements of [iterable] at position [index] in this collection.
215//     // ///
216//     // /// Each element in [iterable] can be a [DataRow] or a [List].
217//     // fn insertAll(index: i64, iterable: Iterable) {
218//     //     // self.base.insertAll(index, iterable.map(toDataRow));
219//     // }
220// }
dataflow/row.rs

dataflow/
row.rs
