public static Hash /*!*/ InitializeCopy(RubyContext /*!*/ context, Hash /*!*/ self, [NotNull] Hash /*!*/ source)
{
self.DefaultProc = source.DefaultProc;
self.DefaultValue = source.DefaultValue;
IDictionaryOps.ReplaceData(self, source);
return(self);
}
public static Hash GroupBy(CallSiteStorage <EachSite> /*!*/ each, [NotNull] BlockParam /*!*/ predicate, object self)
{
var grouped = new Dictionary <object, object>();
Each(each, self, Proc.Create(each.Context, delegate(BlockParam /*!*/ selfBlock, object _, object item) {
object blockResult;
if (predicate.Yield(item, out blockResult))
{
return(selfBlock.PropagateFlow(predicate, blockResult));
}
RubyArray existingGroup = IDictionaryOps.GetElement(each.Context, grouped, blockResult) as RubyArray;
if (existingGroup != null)
{
existingGroup.Add(item);
}
else
{
IDictionaryOps.SetElement(each.Context, grouped, blockResult, new RubyArray {
item
});
}
return(null);
}));
return(new Hash(grouped));
}
public static Hash /*!*/ Replace(RubyContext /*!*/ context, Hash /*!*/ self, object other)
{
if (Object.ReferenceEquals(self, other))
{
return(self);
}
RubyUtils.RequiresNotFrozen(context, self);
// If we are copying from another Hash, copy the default value/block, otherwise set to nil
Hash otherHash = other as Hash;
self.DefaultValue = (otherHash != null) ? otherHash.DefaultValue : null;
self.DefaultProc = (otherHash != null) ? otherHash.DefaultProc : null;
return(IDictionaryOps.ReplaceData(self, IDictionaryOps.ConvertToHash(context, other)));
}
public static Hash /*!*/ Replace(RubyContext /*!*/ context, Hash /*!*/ self, [DefaultProtocol, NotNull] IDictionary <object, object> /*!*/ other)
{
if (Object.ReferenceEquals(self, other))
{
self.RequireNotFrozen();
return(self);
}
Hash otherHash = other as Hash;
if (otherHash != null)
{
self.DefaultValue = otherHash.DefaultValue;
self.DefaultProc = otherHash.DefaultProc;
}
return(IDictionaryOps.ReplaceData(self, other));
}
public static object Shift(RubyContext /*!*/ context, Hash /*!*/ self)
{
RubyUtils.RequiresNotFrozen(context, self);
if (self.Count == 0)
{
return(_DefaultSite.Target(_DefaultSite, context, self, null));
}
IEnumerator <KeyValuePair <object, object> > e = self.GetEnumerator();
e.MoveNext();
KeyValuePair <object, object> pair = e.Current;
self.Remove(pair.Key);
return(IDictionaryOps.MakeArray(pair));
}
public static object Shift(CallSiteStorage <Func <CallSite, Hash, object, object> > /*!*/ storage, Hash /*!*/ self)
{
self.RequireNotFrozen();
if (self.Count == 0)
{
var site = storage.GetCallSite("default", 1);
return(site.Target(site, self, null));
}
IEnumerator <KeyValuePair <object, object> > e = self.GetEnumerator();
e.MoveNext();
KeyValuePair <object, object> pair = e.Current;
self.Remove(pair.Key);
return(IDictionaryOps.MakeArray(pair));
}
public static Hash /*!*/ CreateHash(RubyClass /*!*/ self, [NotNull] params object[] items)
{
// arg0: hash or first elem
// argk: (k-1)th elem
int itemCount = items.Length;
IDictionary <object, object> hash = null;
if (itemCount == 0 || itemCount == 1 && (hash = items[0] as IDictionary <object, object>) != null)
{
Hash newHash = _CreateHashSite.Target(_CreateHashSite, self.Context, self);
return(hash != null?IDictionaryOps.ReplaceData(newHash, hash) : newHash);
}
if (itemCount % 2 != 0)
{
throw new ArgumentException("odd number of arguments for Hash");
}
return(RubyUtils.MakeHash(self.Context, items));
}
public static MutableString /*!*/ ToPrintedString(RubyContext /*!*/ context, object obj)
{
IDictionary <object, object> hash;
List <object> list;
MutableString str;
if ((list = obj as List <object>) != null)
{
return(IListOps.Join(context, list, Environment.NewLine));
}
else if ((hash = obj as IDictionary <object, object>) != null)
{
return(IDictionaryOps.ToString(context, hash));
}
else if (obj == null)
{
return(MutableString.Create("nil"));
}
else if (obj is bool)
{
return(MutableString.Create((bool)obj ? "true" : "false"));
}
else if (obj is double)
{
var result = MutableString.Create(obj.ToString());
if ((double)(int)(double)obj == (double)obj)
{
result.Append(".0");
}
return(result);
}
else if ((str = obj as MutableString) != null)
{
return(str);
}
else
{
return(RubySites.ToS(context, obj));
}
}
public static Hash /*!*/ CreateSubclass(RubyClass /*!*/ self, [NotNull] IDictionary <object, object> /*!*/ hash)
{
// creates a new hash and copies entries of the given hash into it (no other objects associated with the has are copied):
return(IDictionaryOps.ReplaceData(Hash.CreateInstance(self), hash));
}
public static MutableString /*!*/ Inspect(RubyContext /*!*/ context, object /*!*/ self)
{
return(IDictionaryOps.ToMutableString(context, ToHash(context, self)));
}
public static Hash /*!*/ Replace(RubyContext /*!*/ context, Hash /*!*/ self, [DefaultProtocol, NotNull] IDictionary <object, object> /*!*/ other)
{
self.Mutate();
return(IDictionaryOps.ReplaceData(self, other));
}