using System; using System.Collections.Generic; using mbts; namespace BCG { internal class MutableAppendTable : IBlueRowCollection { private class MyRow : IBlueRow { private IBlueRow myRow; private int myID; public MyRow(IBlueRow r, int id) { myRow = r; myID = id; } #region IBlueRow Members public IBlueTableSchema schema { get { return myRow.schema; } } public object this[int index] { get { if (myRow.schema[index].colName == "id") return myID; else return myRow[index]; } } public object this[string colName] { get { return colName == "id" ? (object)myID : myRow[colName]; } } #endregion #region IDictionary Members public void Add(object key, object value) { throw new Exception("Row is read only."); } public void Clear() { throw new Exception("Row is read only."); } public bool Contains(object key) { return myRow.Contains(key); } public System.Collections.IDictionaryEnumerator GetEnumerator() { return new BlueRowDictionaryEnumerator(this); } public bool IsFixedSize { get { return true; } } public bool IsReadOnly { get { return true; } } public System.Collections.ICollection Keys { get { return myRow.Keys; } } public void Remove(object key) {throw new Exception("The method or operation is not implemented.");} public System.Collections.ICollection Values { get { object[] vals = new object[myRow.Count]; CopyTo(vals, 0); return vals; } } public object this[object key] { get { return key is string ? this[key as string] : this[(int)key]; } set { throw new Exception("The method or operation is not implemented."); } } #endregion #region ICollection Members public void CopyTo(Array array, int index) { myRow.CopyTo(array, index); array.SetValue(myID, index + myRow.schema["id"].colNo); } public int Count { get { return myRow.Count; } } public bool IsSynchronized { get { return myRow.IsSynchronized; } } public object SyncRoot { get { return myRow.SyncRoot; } } #endregion #region IEnumerable Members System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return new BlueRowEnumerator(this); } #endregion } private BlueTable myRows; private int myID = 0; /// /// maps the table no to a dictionary containing the /// local IDs to a row in the final big table /// private Dictionary> myIDMap = new Dictionary>(); public MutableAppendTable(IBlueTableSchema schema) { myRows = new BlueTable(schema); } public IBlueRow addRow(IBlueRow r, int tableNo) { if (!myIDMap.ContainsKey(tableNo)) myIDMap.Add(tableNo, new Dictionary()); IBlueRow nr = new MyRow(r, myID++); // BlueDataUtility.getNewReplacedRow(r, myID++, "id"); myRows.addRow(nr); myIDMap[tableNo].Add((int)r["id"], nr); return nr; } public IBlueRow removeRow(IBlueRow r, int tableNo) { IBlueRow dr = myIDMap[tableNo][(int)r["id"]]; myRows.deleteRow(dr); myIDMap[tableNo].Remove((int)r["id"]); return dr; } public IBlueRowCollection removeTable(int tableNo) { if (!myIDMap.ContainsKey(tableNo)) return null; else { BlueTable rv = new BlueTable(myRows.schema); foreach (IBlueRow r in myIDMap[tableNo].Values) rv.addRow(r); myRows.deleteRows(rv); myIDMap.Remove(tableNo); return rv; } } public void clear() { myRows.clear(); myIDMap.Clear(); } #region IBlueRowCollection Members public IBlueRow this[int id] { get { return myRows[id]; } } public IBlueTableSchema schema { get { return myRows.schema; } } public bool containsID(int id) {return myRows.containsID(id);} #endregion #region ICollection Members public void CopyTo(Array array, int index) { myRows.CopyTo(array, index); } public int Count { get { return myRows.Count; } } public bool IsSynchronized { get { return myRows.IsSynchronized; } } public object SyncRoot { get { return myRows.SyncRoot; } } #endregion #region IEnumerable Members public System.Collections.IEnumerator GetEnumerator() {return myRows.GetEnumerator();} #endregion } /// /// MutableStream can append multiple streams /// as well as give the user the flexibility /// to append (or remove) more streams at /// runtime /// public class MutableAppendStream : ViewStream { private bool mySubscriptionActive = false; private MutableAppendTable myTable; private int myMovingIndex; private Dictionary> myStreamIndex = new Dictionary>(); private bool _allign_col_orders = true; public MutableAppendStream(params ViewStream[] streams) : this(new List(streams)) { } public MutableAppendStream(bool allign_col_order, params ViewStream[] streams) : this(allign_col_order, new List(streams)) { } public MutableAppendStream(ICollection streams) : this(true, streams) { } public MutableAppendStream(bool allign_col_orders, ICollection streams) { _allign_col_orders = allign_col_orders; foreach (ViewStream vs in streams) { myMovingIndex++; ViewStream pj = new ChangeTableNameStream(vs, myMovingIndex.ToString()); if (_allign_col_orders) pj = new ProjectStream(pj, "!"); myStreamIndex.Add(myMovingIndex, new Pair(vs, pj)); } } public void addStream(ViewStream vs) { myMovingIndex++; ///the change name is done to identify the callbacks, and the project to ///make all the schemas col orders the same ViewStream pj = new ChangeTableNameStream(vs, myMovingIndex.ToString()); if (_allign_col_orders) pj = new ProjectStream(pj, "!"); myStreamIndex.Add(myMovingIndex, new Pair(vs, pj)); if (mySubscriptionActive) pj.onChange += myHandleStreamChanges; } public void removeStream(ViewStream vs) { int index = -1; foreach (KeyValuePair> p in myStreamIndex) { if (p.Value.first == vs) { index = p.Key; if (mySubscriptionActive) { p.Value.second.onChange -= myHandleStreamChanges; if (myTable != null) { IBlueRowCollection delRows = myTable.removeTable(p.Key); if (delRows != null) myFireEvent(new DataPacket(myTable, new BlueTable(myTable.schema), delRows)); } } break; } if (index > 0) myStreamIndex.Remove(index); } } protected override void myOnFirstSubscriber() { mySubscriptionActive = true; foreach (KeyValuePair> p in myStreamIndex) p.Value.second.onChange += myHandleStreamChanges; } protected override void myOnLastSubscriber() { mySubscriptionActive = false; foreach (KeyValuePair> p in myStreamIndex) p.Value.second.onChange -= myHandleStreamChanges; if (myTable != null) myTable.clear(); } private void myHandleStreamChanges(object newValue) { DataPacket dp = newValue as DataPacket; myTable = myTable ?? new MutableAppendTable(new BlueTableSchema("MutableAppend", dp.schema.columnInfo)); BlueTable adds = new BlueTable(myTable.schema), dels = new BlueTable(myTable.schema); int index = Int32.Parse(dp.schema.tableName); foreach (IBlueRow r in dp.deletedRows) { IBlueRow dr = myTable.removeRow(r, index); dels.addRow(dr); } foreach (IBlueRow r in dp.addedRows) { IBlueRow nr = myTable.addRow(r, index); adds.addRow(nr); } myFireEvent(new DataPacket(myTable, adds, dels)); } } }