ICodeFormattable, IStructuralEquatable {

internal DictionaryStorage _storage;

internal static object MakeDict(CodeContext/*!*/ context, PythonType cls) {

if (cls == TypeCache.Dict) {

return new PythonDictionary();

}

return PythonCalls.Call(context, cls);

}

#region Constructors

public PythonDictionary() {

_storage = EmptyDictionaryStorage.Instance;

}

internal PythonDictionary(DictionaryStorage storage) {

_storage = storage;

}

internal PythonDictionary(IDictionary dict) {

var storage = new CommonDictionaryStorage();

foreach (DictionaryEntry de in dict) {

storage.AddNoLock(de.Key, de.Value);

}

_storage = storage;

}

internal PythonDictionary(IDictionary<object, object> dict) {

var storage = new CommonDictionaryStorage();

foreach (var pair in dict) {

storage.AddNoLock(pair.Key, pair.Value);

}

_storage = storage;

}

internal PythonDictionary(PythonDictionary dict) {

_storage = dict._storage.Clone();

}

internal PythonDictionary(CodeContext/*!*/ context, object o)

: this() {

update(context, o);

}

internal PythonDictionary(int size) {

_storage = size == 0 ? (DictionaryStorage)EmptyDictionaryStorage.Instance : new CommonDictionaryStorage(size);

}

internal static PythonDictionary FromIAC(CodeContext context, PythonDictionary iac) {

return iac.GetType() == typeof(PythonDictionary) ? iac : MakeDictFromIAC(context, iac);

}

internal static PythonDictionary MakeDictFromIAC(CodeContext context, object iac) {

return new PythonDictionary(new ObjectAttributesAdapter(context, iac));

}

internal static PythonDictionary MakeSymbolDictionary() {

return new PythonDictionary(new StringDictionaryStorage());

}

internal static PythonDictionary MakeSymbolDictionary(int count) {

return new PythonDictionary(new StringDictionaryStorage(count));

}

public void __init__(CodeContext/*!*/ context, object o\u00F8, [ParamDictionary]IDictionary<object, object> kwArgs) {

update(context, o\u00F8);

update(context, kwArgs);

}

public void __init__(CodeContext/*!*/ context, [ParamDictionary]IDictionary<object, object> kwArgs) {

update(context, kwArgs);

}

public void __init__(CodeContext/*!*/ context, object o\u00F8) {

update(context, o\u00F8);

}

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]

public void __init__() {

}

#endregion

#region IDictionary<object,object> Members

[PythonHidden]

public void Add(object key, object value) {

_storage.Add(ref _storage, key, value);

}

[PythonHidden]

public bool ContainsKey(object key) {

return _storage.Contains(key);

}

[PythonHidden]

public ICollection<object> Keys {

// Convert to an array since keys() is slow to iterate over in most of the cases where we use this

get { return _storage.GetKeys().ToArray(); }

}

[PythonHidden]

public bool Remove(object key) {

try {

__delitem__(key);

return true;

} catch (KeyNotFoundException) {

return false;

}

}

[PythonHidden]

public bool RemoveDirect(object key) {

// Directly remove the value, without calling __delitem__

// This is used to implement pop() in a manner consistent with CPython, which does

// not call __delitem__ on pop().

return _storage.Remove(ref _storage, key);

}

[PythonHidden]

public bool TryGetValue(object key, out object value) {

if (_storage.TryGetValue(key, out value)) {

return true;

}

// we need to manually look up a slot to get the correct behavior when

// the __missing__ function is declared on a sub-type which is an old-class

if (GetType() != typeof(PythonDictionary) &&

PythonTypeOps.TryInvokeBinaryOperator(DefaultContext.Default,

this,

key,

"__missing__",

out value)) {

return true;

}

return false;

}

internal bool TryGetValueNoMissing(object key, out object value) {

return _storage.TryGetValue(key, out value);

}

public ICollection<object> Values {

[PythonHidden]

get { return values(); }

}

#endregion

#region ICollection<KeyValuePair<object,object>> Members

[PythonHidden]

public void Add(KeyValuePair<object, object> item) {

_storage.Add(ref _storage, item.Key, item.Value);

}

[PythonHidden]

public void Clear() {

_storage.Clear(ref _storage);

}

[PythonHidden]

public bool Contains(KeyValuePair<object, object> item) {

object result;

return _storage.TryGetValue(item.Key, out result) && PythonOps.IsOrEqualsRetBool(result, item.Value);

}

[PythonHidden]

public void CopyTo(KeyValuePair<object, object>[] array, int arrayIndex) {

_storage.GetItems().CopyTo(array, arrayIndex);

}

public int Count {

[PythonHidden]

get { return _storage.Count; }

}

bool ICollection<KeyValuePair<object, object>>.IsReadOnly {

get { return false; }

}

[PythonHidden]

public bool Remove(KeyValuePair<object, object> item) {

return _storage.Remove(ref _storage, item.Key);

}

#endregion

#region IEnumerable<KeyValuePair<object,object>> Members

[PythonHidden]

public IEnumerator<KeyValuePair<object, object>> GetEnumerator() {

foreach (KeyValuePair<object, object> kvp in _storage.GetItems()) {

yield return kvp;

}

}

#endregion

#region IEnumerable Members

IEnumerator IEnumerable.GetEnumerator() {

return Converter.ConvertToIEnumerator(__iter__());

}

public virtual object __iter__() {

return new DictionaryKeyEnumerator(_storage);

}

#endregion

#region IMapping Members

public object get(object key) {

return DictionaryOps.get(this, key);

}

public object get(object key, object defaultValue) {

return DictionaryOps.get(this, key, defaultValue);

}

public virtual object this[params object[] key] {

get {

if (key == null) {

return GetItem(null);

}

if (key.Length == 0) {

throw PythonOps.TypeError("__getitem__() takes exactly one argument (0 given)");

}

return this[PythonTuple.MakeTuple(key)];

}

set {

if (key == null) {

SetItem(null, value);

return;

}

if (key.Length == 0) {

throw PythonOps.TypeError("__setitem__() takes exactly two argument (1 given)");

}

this[PythonTuple.MakeTuple(key)] = value;

}

}

public virtual object this[object key] {

get {

return GetItem(key);

}

set {

SetItem(key, value);

}

}

internal void SetItem(object key, object value) {

_storage.Add(ref _storage, key, value);

}

private object GetItem(object key) {

object ret;

if (TryGetValue(key, out ret)) {

return ret;

}

throw PythonOps.KeyError(key);

}

public virtual void __delitem__(object key) {

if (!RemoveDirect(key)) {

throw PythonOps.KeyError(key);

}

}

public virtual void __delitem__(params object[] key) {

if (key == null) {

__delitem__((object)null);

} else if (key.Length > 0) {

__delitem__(PythonTuple.MakeTuple(key));

} else {

throw PythonOps.TypeError("__delitem__() takes exactly one argument (0 given)");

}

}

#endregion

#region IPythonContainer Members

public virtual int __len__() {

return Count;

}

#endregion

#region Python dict implementation

public void clear() {

_storage.Clear(ref _storage);

}

public object pop(object key) {

return DictionaryOps.pop(this, key);

}

public object pop(object key, object defaultValue) {

return DictionaryOps.pop(this, key, defaultValue);

}

public PythonTuple popitem() {

return DictionaryOps.popitem(this);

}

public object setdefault(object key) {

return DictionaryOps.setdefault(this, key);

}

public object setdefault(object key, object defaultValue) {

return DictionaryOps.setdefault(this, key, defaultValue);

}

public DictionaryItemView items() => new DictionaryItemView(this);

public DictionaryKeyView keys() => new DictionaryKeyView(this);

public DictionaryValueView values() => new DictionaryValueView(this);

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]

public void update() {

}

public void update(CodeContext/*!*/ context, [ParamDictionary]IDictionary<object, object> other\u00F8) {

DictionaryOps.update(context, this, other\u00F8);

}

public void update(CodeContext/*!*/ context, object other\u00F8) {

DictionaryOps.update(context, this, other\u00F8);

}

public void update(CodeContext/*!*/ context, object other\u00F8, [ParamDictionary]IDictionary<object, object> otherArgs\u00F8) {

DictionaryOps.update(context, this, other\u00F8);

DictionaryOps.update(context, this, otherArgs\u00F8);

}

private static object fromkeysAny(CodeContext/*!*/ context, PythonType cls, object o, object value) {

PythonDictionary pyDict;

object dict;

if (cls == TypeCache.Dict) {

string str;

// creating our own dict, try and get the ideal size and add w/o locks

if (o is ICollection ic) {

pyDict = new PythonDictionary(new CommonDictionaryStorage(ic.Count));

} else if ((str = o as string) != null) {

pyDict = new PythonDictionary(str.Length);

} else {

pyDict = new PythonDictionary();

}

IEnumerator i = PythonOps.GetEnumerator(o);

while (i.MoveNext()) {

pyDict._storage.AddNoLock(ref pyDict._storage, i.Current, value);

}

return pyDict;

} else {

// call the user type constructor

dict = MakeDict(context, cls);

pyDict = dict as PythonDictionary;

}

if (pyDict != null) {

// then store all the keys with their associated value

IEnumerator i = PythonOps.GetEnumerator(o);

while (i.MoveNext()) {

pyDict[i.Current] = value;

}

} else {

// slow path, cls.__new__ returned a user defined dictionary instead of a PythonDictionary.

PythonContext pc = context.LanguageContext;

IEnumerator i = PythonOps.GetEnumerator(o);

while (i.MoveNext()) {

pc.SetIndex(dict, i.Current, value);

}

}

return dict;

}

[ClassMethod]

public static object fromkeys(CodeContext context, PythonType cls, object seq) {

return fromkeys(context, cls, seq, null);

}

[ClassMethod]

public static object fromkeys(CodeContext context, PythonType cls, object seq, object value) {

if (seq is PythonRange xr) {

int n = xr.__len__();

object ret = context.LanguageContext.CallSplat(cls);

if (ret.GetType() == typeof(PythonDictionary)) {

PythonDictionary dr = ret as PythonDictionary;

for (int i = 0; i < n; i++) {

dr[xr[i]] = value;

}

} else {

// slow path, user defined dict

PythonContext pc = context.LanguageContext;

for (int i = 0; i < n; i++) {

pc.SetIndex(ret, xr[i], value);

}

}

return ret;

}

return fromkeysAny(context, cls, seq, value);

}

public virtual PythonDictionary copy(CodeContext/*!*/ context) {

return new PythonDictionary(_storage.Clone());

}

public virtual bool __contains__(object key) {

return _storage.Contains(key);

}

// Dictionary has an odd not-implemented check to support custom dictionaries and therefore

// needs a custom __eq__ / __ne__ implementation.

[return: MaybeNotImplemented]

public object __eq__(CodeContext/*!*/ context, object other) {

if (!(other is PythonDictionary || other is IDictionary<object, object>))

return NotImplementedType.Value;

return ScriptingRuntimeHelpers.BooleanToObject(

((IStructuralEquatable)this).Equals(other, context.LanguageContext.EqualityComparerNonGeneric)

);

}

[return: MaybeNotImplemented]

public object __ne__(CodeContext/*!*/ context, object other) {

if (!(other is PythonDictionary || other is IDictionary<object, object>))

return NotImplementedType.Value;

return ScriptingRuntimeHelpers.BooleanToObject(

!((IStructuralEquatable)this).Equals(other, context.LanguageContext.EqualityComparerNonGeneric)

);

}

[return: MaybeNotImplemented]

public NotImplementedType __gt__(CodeContext context, object other) => NotImplementedType.Value;

[return: MaybeNotImplemented]

public NotImplementedType __lt__(CodeContext context, object other) => NotImplementedType.Value;

[return: MaybeNotImplemented]

public NotImplementedType __ge__(CodeContext context, object other) => NotImplementedType.Value;

[return: MaybeNotImplemented]

public NotImplementedType __le__(CodeContext context, object other) => NotImplementedType.Value;

#endregion

#region IStructuralEquatable Members

public const object __hash__ = null;

int IStructuralEquatable.GetHashCode(IEqualityComparer comparer) {

if (CompareUtil.Check(this)) {

return 0;

}

int res;

SetStorage pairs = new SetStorage();

foreach (KeyValuePair<object, object> kvp in _storage.GetItems()) {

pairs.AddNoLock(PythonTuple.MakeTuple(kvp.Key, kvp.Value));

}

CompareUtil.Push(this);

try {

IStructuralEquatable eq = FrozenSetCollection.Make(pairs);

res = eq.GetHashCode(comparer);

} finally {

CompareUtil.Pop(this);

}

return res;

}

bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer) {

return EqualsWorker(other, comparer);

}

private bool EqualsWorker(object other, IEqualityComparer comparer) {

if (Object.ReferenceEquals(this, other)) return true;

if (!(other is IDictionary<object, object> oth)) return false;

if (oth.Count != Count) return false;

if (other is PythonDictionary pd) {

return ValueEqualsPythonDict(pd, comparer);

}

// we cannot call Compare here and compare against zero because Python defines

// value equality even if the keys/values are unordered.

foreach (object o in keys()) {

object res;

if (!oth.TryGetValue(o, out res)) return false;

CompareUtil.Push(res);

try {

var val = this[o];

if (comparer == null) {

if (!PythonOps.IsOrEqualsRetBool(res, val)) return false;

} else {

if (!ReferenceEquals(res, val) && !comparer.Equals(res, val)) return false;

}

} finally {

CompareUtil.Pop(res);

}

}

return true;

}

private bool ValueEqualsPythonDict(PythonDictionary pd, IEqualityComparer comparer) {

foreach (object o in keys()) {

object res;

if (!pd.TryGetValueNoMissing(o, out res)) return false;

CompareUtil.Push(res);

try {

var val = this[o];

if (comparer == null) {

if (!PythonOps.IsOrEqualsRetBool(res, val)) return false;

} else {

if (!ReferenceEquals(res, val) && !comparer.Equals(res, val)) return false;

}

} finally {

CompareUtil.Pop(res);

}

}

return true;

}

#endregion

#region IDictionary Members

[PythonHidden]

public bool Contains(object key) {

return __contains__(key);

}

internal class DictEnumerator : IDictionaryEnumerator {

private readonly IEnumerator<KeyValuePair<object, object>> _enumerator;

private bool _moved;

public DictEnumerator(IEnumerator<KeyValuePair<object, object>> enumerator) {

_enumerator = enumerator;

}

#region IDictionaryEnumerator Members

public DictionaryEntry Entry {

get {

// PythonList<T> enumerator doesn't throw, so we need to.

if (!_moved) throw new InvalidOperationException();

return new DictionaryEntry(_enumerator.Current.Key, _enumerator.Current.Value);

}

}

public object Key {

get { return Entry.Key; }

}

public object Value {

get { return Entry.Value; }

}

#endregion

#region IEnumerator Members

public object Current {

get { return Entry; }

}

public bool MoveNext() {

if (_enumerator.MoveNext()) {

_moved = true;

return true;

}

_moved = false;

return false;

}

public void Reset() {

_enumerator.Reset();

_moved = false;

}

#endregion

}

IDictionaryEnumerator IDictionary.GetEnumerator() {

return new DictEnumerator(_storage.GetItems().GetEnumerator());

}

bool IDictionary.IsFixedSize {

get { return false; }

}

bool IDictionary.IsReadOnly {

get { return false; }

}

ICollection IDictionary.Keys {

get { return keys(); }

}

ICollection IDictionary.Values {

get { return values(); }

}

void IDictionary.Remove(object key) {

((IDictionary<object, object>)this).Remove(key);

}

#endregion

#region ICollection Members

void ICollection.CopyTo(Array array, int index) {

throw new NotImplementedException("The method or operation is not implemented.");

}

bool ICollection.IsSynchronized {

get { return false; }

}

object ICollection.SyncRoot {

get { return null; }

}

#endregion

#region ICodeFormattable Members

public virtual string/*!*/ __repr__(CodeContext/*!*/ context) {

return DictionaryOps.__repr__(context, this);

}

#endregion

internal bool TryRemoveValue(object key, out object value) {

return _storage.TryRemoveValue(ref _storage, key, out value);

}

#region Debugger View

internal class DebugProxy {

private readonly PythonDictionary _dict;

public DebugProxy(PythonDictionary dict) {

_dict = dict;

}

[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]

public List<KeyValueDebugView> Members {

get {

var res = new List<KeyValueDebugView>();

foreach (var v in _dict) {

res.Add(new KeyValueDebugView(v.Key, v.Value));

}

return res;

}

}

}

[DebuggerDisplay("{Value}", Name = "{Key,nq}", Type = "{TypeInfo,nq}")]

internal class KeyValueDebugView {

public readonly object Key;

public readonly object Value;

public KeyValueDebugView(object key, object value) {

Key = key;

Value = value;

}

[DebuggerBrowsable(DebuggerBrowsableState.Never)]

public string TypeInfo {

get {

#pragma warning disable IPY04 // Direct call to PythonTypeOps.GetName

return "Key: " + PythonTypeOps.GetName(Key) + ", " + "Value: " + PythonTypeOps.GetName(Value);

#pragma warning restore IPY04

}

}

}

#endregion

private readonly CommonDictionaryStorage/*!*/ _storage = new CommonDictionaryStorage();

public EnvironmentDictionaryStorage() {

AddEnvironmentVars();

}

private void AddEnvironmentVars() {

try {

foreach (DictionaryEntry de in Environment.GetEnvironmentVariables()) {

_storage.Add(de.Key, de.Value);

}

} catch (SecurityException) {

// environment isn't available under partial trust

}

}

public override void Add(ref DictionaryStorage storage, object key, object value) {

_storage.Add(key, value);

if (key is string s1 && value is string s2) {

Environment.SetEnvironmentVariable(s1, s2);

}

}

public override bool Remove(ref DictionaryStorage storage, object key) {

bool res = _storage.Remove(key);

if (key is string s) {

Environment.SetEnvironmentVariable(s, string.Empty);

}

return res;

}

/// <summary>

/// Since <see cref="EnvironmentDictionaryStorage"/> is always mutable, this is a no-op.

/// </summary>

/// <param name="storage">Ignored.</param>

/// <returns><c>this</c></returns>

public override DictionaryStorage AsMutable(ref DictionaryStorage storage) => this;

public override bool Contains(object key) {

return _storage.Contains(key);

}

public override bool TryGetValue(object key, out object value) {

return _storage.TryGetValue(key, out value);

}

public override int Count {

get { return _storage.Count; }

}

public override void Clear(ref DictionaryStorage storage) {

foreach (var x in GetItems()) {

if (x.Key is string key) {

Environment.SetEnvironmentVariable(key, string.Empty);

}

}

_storage.Clear(ref storage);

}

public override List<KeyValuePair<object, object>> GetItems() {

return _storage.GetItems();

}

private readonly int _size;

private readonly DictionaryStorage _dict;

private readonly IEnumerator<object> _keys;

private int _pos;

internal DictionaryKeyEnumerator(DictionaryStorage dict) {

_dict = dict;

_size = dict.Count;

_keys = dict.GetKeys().GetEnumerator();

_pos = -1;

}

bool IEnumerator.MoveNext() {

if (_size != _dict.Count) {

_pos = _size - 1; // make the length 0

throw PythonOps.RuntimeError("dictionary changed size during iteration");

}

if (_keys.MoveNext()) {

_pos++;

return true;

} else {

return false;

}

}

void IEnumerator.Reset() {

_keys.Reset();

_pos = -1;

}

object IEnumerator<object>.Current => _keys.Current;

object IEnumerator.Current => _keys.Current;

void IDisposable.Dispose() { }

public object __iter__() => this;

public int __length_hint__() => _size - _pos - 1;

#region Pickling

public object __reduce__(CodeContext context) {

object iter;

context.TryLookupBuiltin("iter", out iter);

return PythonTuple.MakeTuple(iter, PythonTuple.MakeTuple(PythonList.FromArrayNoCopy(_dict.GetKeys().Skip(_pos + 1).ToArray())));

}

#endregion