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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
namespace Firebase.Database.Offline {
internal class OfflineCacheAdapter<TKey, T> : IDictionary<string, T>, IDictionary {
private readonly IDictionary<string, OfflineEntry> database;
public OfflineCacheAdapter(IDictionary<string, OfflineEntry> database) {
this.database = database;
}
public void CopyTo(Array array, int index) {
throw new NotImplementedException();
}
public bool IsSynchronized { get; }
public object SyncRoot { get; }
object IDictionary.this[object key] {
get => database[key.ToString()].Deserialize<T>();
set {
var keyString = key.ToString();
if (database.ContainsKey(keyString))
database[keyString] = new OfflineEntry(keyString, value, database[keyString].Priority,
database[keyString].SyncOptions);
else
database[keyString] = new OfflineEntry(keyString, value, 1, SyncOptions.None);
}
}
ICollection IDictionary.Values { get; }
ICollection IDictionary.Keys { get; }
public bool Contains(object key) {
return ContainsKey(key.ToString());
}
IDictionaryEnumerator IDictionary.GetEnumerator() {
throw new NotImplementedException();
}
public void Remove(object key) {
Remove(key.ToString());
}
public bool IsFixedSize => false;
public void Add(object key, object value) {
Add(key.ToString(), (T) value);
}
public int Count => database.Count;
public bool IsReadOnly => database.IsReadOnly;
public ICollection<string> Keys => database.Keys;
public ICollection<T> Values => database.Values.Select(o => o.Deserialize<T>()).ToList();
public T this[string key] {
get => database[key].Deserialize<T>();
set {
if (database.ContainsKey(key))
database[key] = new OfflineEntry(key, value, database[key].Priority, database[key].SyncOptions);
else
database[key] = new OfflineEntry(key, value, 1, SyncOptions.None);
}
}
public IEnumerator<KeyValuePair<string, T>> GetEnumerator() {
return database.Select(d => new KeyValuePair<string, T>(d.Key, d.Value.Deserialize<T>())).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
public void Add(KeyValuePair<string, T> item) {
Add(item.Key, item.Value);
}
public void Clear() {
database.Clear();
}
public bool Contains(KeyValuePair<string, T> item) {
return ContainsKey(item.Key);
}
public void CopyTo(KeyValuePair<string, T>[] array, int arrayIndex) {
throw new NotImplementedException();
}
public bool Remove(KeyValuePair<string, T> item) {
return database.Remove(item.Key);
}
public void Add(string key, T value) {
database.Add(key, new OfflineEntry(key, value, 1, SyncOptions.None));
}
public bool ContainsKey(string key) {
return database.ContainsKey(key);
}
public bool Remove(string key) {
return database.Remove(key);
}
public bool TryGetValue(string key, out T value) {
OfflineEntry val;
if (database.TryGetValue(key, out val)) {
value = val.Deserialize<T>();
return true;
}
value = default(T);
return false;
}
}
}
|
