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 void CreateOnISeqReturnsSet() { object[] items = new object[] { 1, "a" }; ArrayList a = new ArrayList(items); ISeq s = PersistentList.create(a).seq(); IPersistentSet m = PersistentHashSet.create(s); Expect(m.count(), EqualTo(2)); Expect(m.contains(1)); Expect(m.contains("a")); Expect(m.contains(3), False); }
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 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.Emit(OpCodes.Stfld, fb); } else { objx.EmitLocal(ilg, lb); ilg.Emit(OpCodes.Stfld, fb); } } } ilg.Emit(OpCodes.Pop); } }
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 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); if (form is IObj iobjForm && iobjForm.meta() != null) { return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret)); }
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); }
/// <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); }
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); } }
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); } }
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); }