public void Precache <T> (GroupInfo info) where T : new() { return; if (info == null) { info = GetGroupInfo <T> (); } var type = typeof(T); var tuple = new Tuple <Type, string> (type, info.ToString()); FillGroups(type, info); using (ThreadLock.Lock(groupLocker)) { if (Groups [tuple].Count() == 0) { SetGroups(type, info); } foreach (var group in Groups[tuple]) { if (group.Loaded) { continue; } cacheQueue.AddLast(delegate { LoadItemsForGroup <T> (group); }); } } StartQueue(); }
private InstantDatabaseGroup GetGroup(Type t, GroupInfo info, int section) { var tuple = new Tuple <Type, string> (t, info.ToString()); List <InstantDatabaseGroup> group = null; int count = 0; while ((group == null || group.Count <= section) && count < 5) { if (count > 0) { Console.WriteLine("Trying to fill groups: {0}", count); } using (ThreadLock.Lock(groupLocker)){ Groups.TryGetValue(tuple, out group); } if (group == null) { FillGroups(t, info); } count++; } if (group == null || group.Count == 0) { return(new InstantDatabaseGroup()); } return(group [section]); }
public void AddObjectToDict(object item, Type t) { using (ThreadLock.Lock(groupLocker)) { var primaryKey = GetPrimaryKeyProperty(t); if (primaryKey == null) { return; } object pk = primaryKey.GetValue(item, null); if (!ObjectsDict.ContainsKey(t)) { ObjectsDict.Add(t, new Dictionary <object, object>()); } if (ObjectsDict[t].ContainsKey(pk)) { ObjectsDict[t][pk] = item; } else { ObjectsDict[t].Add(pk, item); } // if (!Objects.ContainsKey (t)) // Objects.Add (t, new List<object> ()); // if (!Objects [t].Contains (item)) // Objects [t].Add (item); } }
public T ObjectForRow <T> (GroupInfo info, int section, int row) where T : new() { if (info == null) { info = GetGroupInfo <T> (); } using (ThreadLock.Lock(memStoreLocker)) { var type = typeof(T); var tuple = new Tuple <Type, string> (type, info.ToString()); if (MemoryStore.ContainsKey(tuple)) { var groups = MemoryStore [tuple]; if (groups.ContainsKey(section)) { var g = groups [section]; if (g.ContainsKey(row)) { return((T)groups [section] [row]); } } } Precache <T> (info, section); return(getObject <T> (info, section, row)); } }
public void ClearMemory(Type type, GroupInfo groupInfo) { var tuple = new Tuple <Type, string> (type, groupInfo.ToString()); using (ThreadLock.Lock(memStoreLocker)){ MemoryStore.Remove(tuple); } Groups.Clear(); }
public void ClearMemory() { using (ThreadLock.Lock(memStoreLocker)) { ObjectsDict.Clear(); ClearMemoryStore(); //Objects.Clear (); //GC.Collect (); } }
public void ClearMemoryStore() { using (ThreadLock.Lock(memStoreLocker)) { MemoryStore.Clear(); using (ThreadLock.Lock(groupLocker)){ Groups.Clear(); GroupInfoDict.Clear(); } } }
public int RowsInSection <T> (GroupInfo info, int section) { if (info == null) { info = GetGroupInfo <T> (); } using (ThreadLock.Lock(groupLocker)) { var group = GetGroup <T> (info, section); return(group.RowCount); } }
private T getObject <T> (GroupInfo info, int section, int row) where T : new() { try{ T item; var t = typeof(T); var group = GetGroup <T> (info, section); string query; if (string.IsNullOrEmpty(info.GroupBy)) { query = string.Format("select * from {0} {1} {2} LIMIT {3}, 1", info.FromString(t.Name), info.FilterString(true), info.OrderByString(true), row); } else { query = string.Format("select * from {0} where {1} = ? {3} {2} LIMIT ? , 1", info.FromString(t.Name), info.GroupBy, info.OrderByString(true), info.FilterString(false)); } item = connection.Query <T> (query, group.GroupString, row).FirstOrDefault(); if (item == null) { return(new T()); } var tuple = new Tuple <Type, string> (t, info.ToString()); using (ThreadLock.Lock(memStoreLocker)) { if (!MemoryStore.ContainsKey(tuple)) { MemoryStore.Add(tuple, new Dictionary <int, Dictionary <int, object> > ()); } var groups = MemoryStore [tuple]; if (!groups.ContainsKey(section)) { groups.Add(section, new Dictionary <int, object> ()); } if (!groups [section].ContainsKey(row)) { groups [section].Add(row, item); } else { groups [section] [row] = item; } AddObjectToDict(item); return(item); } } catch (Exception ex) { Console.WriteLine(ex); return(default(T)); } }
public int NumberOfSections <T> (GroupInfo info) { if (info == null) { info = GetGroupInfo <T> (); } using (ThreadLock.Lock(groupLocker)) { var t = typeof(T); var tuple = new Tuple <Type, string> (t, info.ToString()); if (!Groups.ContainsKey(tuple)) { FillGroups(t, info); } return(Groups [tuple].Count); } }
public void UpdateInstant(Type type, GroupInfo info) { if (info == null) { info = GetGroupInfo(type); } var tuple = new Tuple <Type, string> (type, info.ToString()); using (ThreadLock.Lock(memStoreLocker)) { if (MemoryStore.ContainsKey(tuple)) { MemoryStore [tuple] = new Dictionary <int, Dictionary <int, object> > (); } } FillGroups(type, info); }
private void FillGroups(Type t, GroupInfo info) { List <InstantDatabaseGroup> groups; groups = CreateGroupInfo(t, info); using (ThreadLock.Lock(groupLocker)) { var tuple = new Tuple <Type, string> (t, info.ToString()); if (!Groups.ContainsKey(tuple)) { Groups.Add(tuple, groups); } else { Groups [tuple] = groups; } } }
public string [] QuickJump <T> (GroupInfo info) { if (info == null) { info = GetGroupInfo <T> (); } using (ThreadLock.Lock(groupLocker)) { var t = typeof(T); var tuple = new Tuple <Type, string> (t, info.ToString()); if (!Groups.ContainsKey(tuple)) { FillGroups(t, info); } var groups = Groups [tuple]; var strings = groups.Select(x => string.IsNullOrEmpty(x.GroupString) ? "" : x.GroupString [0].ToString()).ToArray(); return(strings); } }
public string SectionHeader <T> (GroupInfo info, int section) { if (info == null) { info = GetGroupInfo <T> (); } using (ThreadLock.Lock(groupLocker)) { var t = typeof(T); var tuple = new Tuple <Type, string> (t, info.ToString()); if (!Groups.ContainsKey(tuple) || Groups [tuple].Count <= section) { FillGroups(t, info); } try{ return(Groups [tuple] [section].GroupString); } catch (Exception ex) { return(""); } } }
private void LoadItemsForGroup <T> (InstantDatabaseGroup group) where T : new() { try{ if (group.Loaded) { return; } Console.WriteLine("Loading items for group"); var type = typeof(T); string query = string.Format("select * from {0} where {1} = ? {3} {2} LIMIT ? , 50", group.FromString(type.Name), group.GroupBy, group.OrderByString(true), group.FilterString(false)); List <T> items; int current = 0; bool hasMore = true; while (hasMore) { if (string.IsNullOrEmpty(group.GroupBy)) { query = string.Format("select * from {0} {1} {2} LIMIT {3}, 50", group.FromString(type.Name), group.FilterString(true), group.OrderByString(true), current); } items = connection.Query <T> (query, group.GroupString, current).ToList(); { Dictionary <int, object> memoryGroup; using (ThreadLock.Lock(memStoreLocker)){ var tuple = new Tuple <Type, string> (type, group.ToString()); if (!MemoryStore.ContainsKey(tuple)) { MemoryStore.Add(tuple, new Dictionary <int, Dictionary <int, object> > ()); } if (!MemoryStore [tuple].ContainsKey(group.Order)) { try{ MemoryStore [tuple].Add(group.Order, new Dictionary <int, object> ()); } catch (Exception ex) { Console.WriteLine(ex); } } memoryGroup = MemoryStore [tuple] [group.Order]; } for (int i = 0; i < items.Count; i++) { lock (groupLocker) { if (memoryGroup.ContainsKey(i + current)) { memoryGroup [i + current] = items [i]; } else { memoryGroup.Add(i + current, items [i]); } } AddObjectToDict(items [i]); } } current += items.Count; if (current == group.RowCount) { hasMore = false; } } Console.WriteLine("group loaded"); group.Loaded = true; } catch (Exception ex) { Console.WriteLine(ex); } }