public static int test() { Set<Short> s = new HashSet<Short>(); for (short i = 0; i < 100; i++) { s.add(i); s.remove(i - 1); } return s.size(); }
public static bool moreInfo = false; // True iff more info in toString /** * Constructor. * @param collection a Collection holding the Simplex vertices * @throws IllegalArgumentException if there are duplicate vertices */ public Simplex(Collection collection) { this.vertices = Collections.unmodifiableList(new java.util.ArrayList(collection)); this.idNumber = idGenerator++; Set noDups = new HashSet(this); if (noDups.size() != this.vertices.size()) throw new InvalidOperationException("Duplicate vertices in Simplex"); }
public TypeBuilder[] getDependencies() { checkCreated(); var dependencies = new HashSet<TypeBuilder>(); addType(dependencies, baseType); foreach (var t in interfaces) { addType(dependencies, t); } foreach (var a in annotations) { addType(dependencies, a.Type); } foreach (var nt in nestedTypes) { foreach (var t in ((TypeBuilder)nt).getDependencies()) { dependencies.add((TypeBuilder)t); } } foreach (var f in fields) { foreach (var a in f.Annotations) { addType(dependencies, a.Type); } addType(dependencies, f.Type); } foreach (var m in methods) { if (!m.IsExcludedFromCompilation) { foreach (var a in m.Annotations) { addType(dependencies, a.Type); } addType(dependencies, m.ReturnType); foreach (var p in m.Parameters) { foreach (var a in p.Annotations) { addType(dependencies, a.Type); } addType(dependencies, p.Type); } foreach (var e in m.Exceptions) { addType(dependencies, e); } foreach (var instruction in ((MethodBuilder)m).CodeGenerator.Instructions) { switch (instruction.Opcode) { case Getfield: case Getstatic: case Putfield: case Putstatic: addType(dependencies, instruction.Field.DeclaringType); break; case Invokedynamic: case Invokeinterface: case Invokespecial: case Invokestatic: case Invokevirtual: addType(dependencies, instruction.Method.DeclaringType); break; case Anewarray: case Checkcast: case Instanceof: case New: addType(dependencies, instruction.Type); break; } } } } return dependencies.toArray(new TypeBuilder[dependencies.size()]); }
/** * True iff simplices are neighbors. * Two simplices are neighbors if they are the same dimension and they share * a facet. * @param simplex the other Simplex * @return true iff this Simplex is a neighbor of simplex */ public bool isNeighbor(Simplex simplex) { HashSet h = new HashSet(this); h.removeAll(simplex); return (this.size() == simplex.size()) && (h.size() == 1); }
static TypeInfo getFixedType(Library typeSystem, Collection<TypeInfo> bounds) { var filteredBounds = new HashSet<TypeInfo>(bounds); foreach (var ti in bounds) { foreach (var tj in bounds) { if (!BytecodeHelper.hasImplicitConversion(ti, tj)) { filteredBounds.remove(tj); } } } if (filteredBounds.size() != 1) { return null; } else { var result = filteredBounds.single(); if (result == null) { return typeSystem.ObjectType; } else { return result; } } }