forked from jiailiuyan/ironpython3
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathStringDictionaryStorage.cs
More file actions
160 lines (136 loc) · 5.4 KB
/
Copy pathStringDictionaryStorage.cs
File metadata and controls
160 lines (136 loc) · 5.4 KB
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
/* ****************************************************************************
*
* Copyright (c) Microsoft Corporation.
*
* This source code is subject to terms and conditions of the Apache License, Version 2.0. A
* copy of the license can be found in the License.html file at the root of this distribution. If
* you cannot locate the Apache License, Version 2.0, please send an email to
* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
* by the terms of the Apache License, Version 2.0.
*
* You must not remove this notice, or any other, from this software.
*
*
* ***************************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using Microsoft.Scripting.Runtime;
using IronPython.Runtime;
namespace IronPythonTest {
[Serializable]
internal class StringDictionaryStorage : DictionaryStorage {
private readonly IDictionary<string, object>/*!*/ _dict; // the underlying dictionary
private Dictionary<object, object> _objDict;
public StringDictionaryStorage(IDictionary<string, object>/*!*/ dict) {
_dict = dict;
}
public StringDictionaryStorage(IDictionary<string, object> dict, Dictionary<object, object> objDict) {
_dict = dict;
_objDict = objDict;
}
public override void Add(ref DictionaryStorage storage, object key, object value) {
lock (this) {
string strKey = key as string;
if (strKey != null) {
_dict[strKey] = value;
} else {
EnsureObjectDictionary();
_objDict[CustomStringDictionary.NullToObj(key)] = value;
}
}
}
public override bool Contains(object key) {
lock (this) {
string strKey = key as string;
if (strKey != null) {
return _dict.ContainsKey(strKey);
}
if (_objDict != null) {
return _objDict.ContainsKey(CustomStringDictionary.NullToObj(key));
}
return false;
}
}
public override bool Remove(ref DictionaryStorage storage, object key) {
lock (this) {
string strKey = key as string;
if (strKey != null) {
return _dict.Remove(strKey);
}
if (_objDict != null) {
return _objDict.Remove(CustomStringDictionary.NullToObj(key));
}
return false;
}
}
public override bool TryGetValue(object key, out object value) {
lock (this) {
string strKey = key as string;
if (strKey != null) {
return _dict.TryGetValue(strKey, out value);
}
if (_objDict != null) {
return _objDict.TryGetValue(CustomStringDictionary.NullToObj(key), out value);
}
value = null;
return false;
}
}
public override int Count {
get {
lock (this) {
int count = _dict.Count;
if (_objDict != null) {
count += _objDict.Count;
}
return count;
}
}
}
public override void Clear(ref DictionaryStorage storage) {
lock (this) {
_dict.Clear();
if (_objDict != null) {
_objDict.Clear();
}
}
}
public override List<KeyValuePair<object, object>> GetItems() {
List<KeyValuePair<object, object>> res = new List<KeyValuePair<object, object>>();
lock (this) {
foreach (KeyValuePair<string, object> kvp in _dict) {
res.Add(new KeyValuePair<object, object>(kvp.Key, kvp.Value));
}
if (_objDict != null) {
foreach (KeyValuePair<object, object> kvp in _objDict) {
res.Add(kvp);
}
}
}
return res;
}
public override DictionaryStorage Clone() {
lock (this) {
IDictionary<string, object> dict;
ICloneable cloneable = _dict as ICloneable;
if (cloneable != null) {
dict = (IDictionary<string, object>)cloneable.Clone();
} else {
dict = new Dictionary<string, object>(_dict, StringComparer.Ordinal);
}
Dictionary<object, object> objDict = null;
if (_objDict != null) {
objDict = new Dictionary<object, object>(_objDict, DefaultContext.DefaultPythonContext.EqualityComparer);
}
return new StringDictionaryStorage(dict, objDict);
}
}
private void EnsureObjectDictionary() {
if (_objDict == null) {
Interlocked.CompareExchange<Dictionary<object, object>>(ref _objDict, new Dictionary<object, object>(DefaultContext.DefaultPythonContext.EqualityComparer), null);
}
}
}
}