/// <summary>
/// Determines whether the specified Object is equal to the current Object.
/// </summary>
/// <param name="obj">The Object to compare with the current Object.</param>
/// <returns><value>true</value> if the specified Object is equal to the current Object;
/// otherwise, <value>false</value>.
/// </returns>
public override bool Equals(object obj)
{
// I really can't do what the Java version does.
// It casts to a Set. No such thing here. We'll use IPersistentSet instead.
IPersistentSet s = obj as IPersistentSet;
if (s == null)
{
return(false);
}
if (s.count() != count() || s.GetHashCode() != GetHashCode())
{
return(false);
}
for (ISeq seq = s.seq(); seq != null; seq = seq.next())
{
if (!contains(seq.first()))
{
return(false);
}
}
return(true);
}
public void CreateOnEmptyListReturnsEmptySet()
{
ArrayList a = new ArrayList();
IPersistentSet m = PersistentHashSet.createWithCheck(a);
Expect(m.count(), EqualTo(0));
}
public CaseExpr( IPersistentMap sourceSpan, LocalBindingExpr expr, int shift, int mask, int low, int high, Expr defaultExpr,
SortedDictionary<int, Expr> tests, Dictionary<int, Expr> thens, Keyword switchType, Keyword testType, IPersistentSet skipCheck)
{
_sourceSpan = sourceSpan;
_expr = expr;
_shift = shift;
_mask = mask;
//_low = low;
//_high = high;
_defaultExpr = defaultExpr;
_tests = tests;
_thens = thens;
if (switchType != _compactKey && switchType != _sparseKey)
throw new ArgumentException("Unexpected switch type: " + switchType);
//_switchType = switchType;
if (testType != _intKey && testType != _hashEquivKey && testType != _hashIdentityKey)
throw new ArgumentException("Unexpected test type: " + testType);
_testType = testType;
_skipCheck = skipCheck;
ICollection<Expr> returns = new List<Expr>(thens.Values);
returns.Add(defaultExpr);
_returnType = Compiler.MaybeClrType(returns);
if (RT.count(skipCheck) > 0 && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Performance warning, {0}:{1} - hash collision of some case test constants; if selected, those entries will be tested sequentially.",
Compiler.SourcePathVar.deref(),RT.get(sourceSpan,RT.StartLineKey));
}
}
public virtual bool Add(object o)
{
if (link != null)
{
IPersistent obj = (IPersistent) o;
if (link.IndexOf(obj) >= 0)
{
return false;
}
if (link.Size == BTREE_THRESHOLD)
{
Set = Storage.CreateSet();
for (int i = 0, n = link.Size; i < n; i++)
{
Set.Add(link.GetRaw(i));
}
link = null;
Modify();
Set.Add(obj);
}
else
{
Modify();
link.Add(obj);
}
return true;
}
else
{
return Set.Add(o);
}
}
public static Expr Parse(ParserContext pcon, IPersistentSet form)
{
ParserContext pconToUse = pcon.EvEx();
bool constant = true;
IPersistentVector keys = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
object e = s.first();
Expr expr = Compiler.Analyze(pconToUse, e);
keys = (IPersistentVector)keys.cons(expr);
if (!(expr is LiteralExpr))
constant = false;
}
Expr ret = new SetExpr(keys);
if (form is IObj && ((IObj)form).meta() != null)
return Compiler.OptionallyGenerateMetaInit(pcon, form, ret);
else if (constant)
{
IPersistentSet set = PersistentHashSet.EMPTY;
for (int i = 0; i < keys.count(); i++)
{
LiteralExpr ve = (LiteralExpr)keys.nth(i);
set = (IPersistentSet)set.cons(ve.Val);
}
return new ConstantExpr(set);
}
else
return ret;
}
public void CreateOnEmptyISeqReturnsEmptySet()
{
object[] items = new object[] { };
ArrayList a = new ArrayList(items);
ISeq s = PersistentList.create(a).seq();
IPersistentSet m = PersistentHashSet.create(s);
Expect(m.count(), EqualTo(0));
}
public static Expr Parse(IPersistentSet form)
{
IPersistentVector keys = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
object e = s.first();
keys = (IPersistentVector)keys.cons(Compiler.GenerateAST(e));
}
Expr ret = new SetExpr(keys);
return Compiler.OptionallyGenerateMetaInit(form, ret);
}
public static bool setEquals(IPersistentSet s1, object obj)
{
// I really can't do what the Java version does.
// It casts to a Set. No such thing here. We'll use IPersistentSet instead.
if (s1 == obj)
{
return(true);
}
#if CLR2
// No System.Collections.Generic.ISet<T>
#else
ISet <Object> is2 = obj as ISet <Object>;
if (is2 != null)
{
if (is2.Count != s1.count())
{
return(false);
}
foreach (Object elt in is2)
{
if (!s1.contains(elt))
{
return(false);
}
}
return(true);
}
#endif
IPersistentSet s2 = obj as IPersistentSet;
if (s2 == null)
{
return(false);
}
if (s2.count() != s1.count())
{
return(false);
}
for (ISeq seq = s2.seq(); seq != null; seq = seq.next())
{
if (!s1.contains(seq.first()))
{
return(false);
}
}
return(true);
}
internal ScalableSet(StorageImpl storage, int initialSize)
: base(storage)
{
if (initialSize <= BTREE_THRESHOLD)
{
link = storage.CreateLink(initialSize);
}
else
{
Set = storage.CreateSet();
}
}
public void CreateOnListReturnsSet()
{
object[] items = new object[] { 1, "a" };
ArrayList a = new ArrayList(items);
IPersistentSet m = PersistentHashSet.createWithCheck(a);
Expect(m.count(), EqualTo(2));
Expect(m.contains(1));
Expect(m.contains("a"));
Expect(m.contains(3), False);
}
public static Expr Parse(IPersistentSet form)
{
IPersistentVector keys = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
object e = s.first();
keys = (IPersistentVector)keys.cons(Compiler.GenerateAST(e));
}
Expr ret = new SetExpr(keys);
return(Compiler.OptionallyGenerateMetaInit(form, ret));
}
private static List <CustomAttributeBuilder> CreateCustomAttributeBuilders(IMapEntry me)
{
Type t = (Type)me.key();
IPersistentSet inits = (IPersistentSet)me.val();
List <CustomAttributeBuilder> builders = new List <CustomAttributeBuilder>(inits.count());
for (ISeq s = RT.seq(inits); s != null; s = s.next())
{
IPersistentMap init = (IPersistentMap)s.first();
builders.Add(CreateCustomAttributeBuilder(t, init));
}
return(builders);
}
public static bool setEquals(IPersistentSet s1, object obj)
{
// I really can't do what the Java version does.
// It casts to a Set. No such thing here. We'll use IPersistentSet instead.
if (s1 == obj)
{
return(true);
}
if (obj is ISet <Object> is2)
{
if (is2.Count != s1.count())
{
return(false);
}
foreach (Object elt in is2)
{
if (!s1.contains(elt))
{
return(false);
}
}
return(true);
}
if (!(obj is IPersistentSet s2))
{
return(false);
}
if (s2.count() != s1.count())
{
return(false);
}
for (ISeq seq = s2.seq(); seq != null; seq = seq.next())
{
if (!s1.contains(seq.first()))
{
return(false);
}
}
return(true);
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
bool allKeysConstant = true;
bool allConstantKeysUnique = true;
IPersistentSet constantKeys = PersistentHashSet.EMPTY;
for (int i = 0; i < _keyvals.count(); i += 2)
{
Expr k = (Expr)_keyvals.nth(i);
if (k is LiteralExpr)
{
object kval = k.Eval();
if (constantKeys.contains(kval))
{
allConstantKeysUnique = false;
}
else
{
constantKeys = (IPersistentSet)constantKeys.cons(kval);
}
}
else
{
allKeysConstant = false;
}
}
MethodExpr.EmitArgsAsArray(_keyvals, objx, ilg);
if ((allKeysConstant && allConstantKeysUnique) || (_keyvals.count() <= 2))
{
ilg.EmitCall(Compiler.Method_RT_mapUniqueKeys);
}
else
{
ilg.EmitCall(Compiler.Method_RT_map);
}
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public static bool IsAssemblyExportable(Assembly assembly, IPersistentSet checkedAssemblies)
{
if (checkedAssemblies.contains(assembly))
{
return(true);
}
foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
{
if (referencedAssembly.Name == "UnityEditor" || referencedAssembly.Name == "Assembly-CSharp-Editor")
{
return(false);
}
if (!IsAssemblyExportable(Assembly.Load(referencedAssembly), (IPersistentSet)checkedAssemblies.cons(assembly)))
{
return(false);
}
}
return(true);
}
public static Expr Parse(ParserContext pcon, IPersistentSet form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool constant = true;
IPersistentVector keys = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
object e = s.first();
Expr expr = Compiler.Analyze(pconToUse, e);
keys = (IPersistentVector)keys.cons(expr);
if (!(expr is LiteralExpr))
{
constant = false;
}
}
Expr ret = new SetExpr(keys);
IObj iobjForm = form as IObj;
if (iobjForm != null && iobjForm.meta() != null)
{
return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret));
}
else if (constant)
{
IPersistentSet set = PersistentHashSet.EMPTY;
for (int i = 0; i < keys.count(); i++)
{
LiteralExpr ve = (LiteralExpr)keys.nth(i);
set = (IPersistentSet)set.cons(ve.Val);
}
return(new ConstantExpr(set));
}
else
{
return(ret);
}
}
public static Expr Parse(ParserContext pcon, IPersistentSet form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool constant = true;
IPersistentVector keys = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
object e = s.first();
Expr expr = Compiler.Analyze(pconToUse, e);
keys = (IPersistentVector)keys.cons(expr);
if (!(expr is LiteralExpr))
{
constant = false;
}
}
Expr ret = new SetExpr(keys);
if (form is IObj iobjForm && iobjForm.meta() != null)
{
return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret));
}
/// <summary>
/// Is one value preferred over another?
/// </summary>
/// <param name="x">The first dispatch value.</param>
/// <param name="y">The second dispatch value.</param>
/// <returns><value>true</value> if <paramref name="x"/> is preferred over <paramref name="y"/></returns>
private bool Prefers(object x, object y)
{
IPersistentSet xprefs = (IPersistentSet)PreferTable.valAt(x);
if (xprefs != null && xprefs.contains(y))
{
return(true);
}
for (ISeq ps = RT.seq(_parents.invoke(y)); ps != null; ps = ps.next())
{
if (Prefers(x, ps.first()))
{
return(true);
}
}
for (ISeq ps = RT.seq(_parents.invoke(x)); ps != null; ps = ps.next())
{
if (Prefers(ps.first(), y))
{
return(true);
}
}
return(false);
}
private static Expression GenerateSetExpr(IPersistentSet set)
{
Expression[] args = new Expression[set.count()];
int i = 0;
for (ISeq s = RT.seq(set); s != null; s = s.next(), i++)
args[i] = MaybeBox(Generate(s.first()));
Expression argArray = Expression.NewArrayInit(typeof(object), args);
Expression ret = Expression.Call(Method_CGen_MakeSet, argArray);
ret = OptionallyGenerateMetaInit(set, ret);
return ret;
}
internal void EmitLetFnInits(CljILGen ilg, LocalBuilder localBuilder, ObjExpr objx, IPersistentSet letFnLocals)
{
if (_typeBuilder != null)
{
// Full compile
ilg.Emit(OpCodes.Castclass, _typeBuilder);
for (ISeq s = RT.keys(Closes); s != null; s = s.next())
{
LocalBinding lb = (LocalBinding)s.first();
if (letFnLocals.contains(lb))
{
FieldBuilder fb;
_closedOverFieldsMap.TryGetValue(lb, out fb);
Type primt = lb.PrimitiveType;
ilg.Emit(OpCodes.Dup); // this
if (primt != null)
{
objx.EmitUnboxedLocal(ilg, lb);
ilg.MaybeEmitVolatileOp(IsVolatile(lb));
ilg.Emit(OpCodes.Stfld, fb);
}
else
{
objx.EmitLocal(ilg, lb);
ilg.MaybeEmitVolatileOp(IsVolatile(lb));
ilg.Emit(OpCodes.Stfld, fb);
}
}
}
ilg.Emit(OpCodes.Pop);
}
}
internal Expression GenLetFnInits(GenContext context, ParameterExpression parm, FnExpr fn, IPersistentSet leFnLocals)
{
// fn is the enclosing IFn, not this.
throw new NotImplementedException();
}
internal Expression GenLetFnInits(GenContext context, ParameterExpression parm, ObjExpr objx, IPersistentSet letFnLocals)
{
ParameterExpression cvtParm = Expression.Parameter(_compiledType,"cvt");
Expression initExpr = Expression.Assign(cvtParm,Expression.Convert(parm, _compiledType));
List<Expression> exprs = new List<Expression>();
exprs.Add(initExpr);
for (ISeq s = RT.keys(_closes); s != null; s = s.next())
{
LocalBinding lb = (LocalBinding)s.first();
if (letFnLocals.contains(lb))
{
FieldBuilder fb;
_closedOverFieldsMap.TryGetValue(lb,out fb);
Type primt = lb.PrimitiveType;
Expression init = primt != null ? objx.GenUnboxedLocal(context, lb) : objx.GenLocal(context,lb);
exprs.Add(Expression.Assign(Expression.Field(_thisParam,fb), init));
}
}
return Expression.Block(new ParameterExpression[] { cvtParm }, exprs);
}
internal Expression GenLetFnInits(GenContext context, ParameterExpression parm, FnExpr fn, IPersistentSet leFnLocals)
{
// TODO: Implement this!!!!!!!!!!!!!!!!
// fn is the enclosing IFn, not this.
throw new NotImplementedException();
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool keysConstant = true;
bool valsConstant = true;
bool allConstantKeysUnique = true;
IPersistentSet constantKeys = PersistentHashSet.EMPTY;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (k is LiteralExpr)
{
object kval = k.Eval();
if (constantKeys.contains(kval))
{
allConstantKeysUnique = false;
}
else
{
constantKeys = (IPersistentSet)constantKeys.cons(kval);
}
}
else
{
keysConstant = false;
}
if (!(v is LiteralExpr))
{
valsConstant = false;
}
}
Expr ret = new MapExpr(keyvals);
IObj iobjForm = form as IObj;
if (iobjForm != null && iobjForm.meta() != null)
{
return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret));
}
//else if (constant)
//{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
// //IPersistentMap m = PersistentHashMap.EMPTY;
// //for (int i = 0; i < keyvals.length(); i += 2)
// // m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
// //return new ConstantExpr(m);
// return ret;
//}
else if (keysConstant)
{
// TBD: Add more detail to exception thrown below.
if (!allConstantKeysUnique)
{
throw new ArgumentException("Duplicate constant keys in map");
}
if (valsConstant)
{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
//IPersistentMap m = PersistentHashMap.EMPTY;
//for (int i = 0; i < keyvals.length(); i += 2)
// m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
//return new ConstantExpr(m);
return(ret);
}
else
{
return(ret);
}
}
else
{
return(ret);
}
}
