enumeration

I have a block of code which is similar to the following: for (NSDictionary *tmp in aCollection) { if ([[bar valueForKey:@"id"] isEqualToString:[tmp valueForKey:@"id"]]) { break; } else { [aCollection addObject:bar]; } } Is this technically an exception in Objective-C 2.0? It appears you cannot mutate a collection with fast enumeration. This is the result of an error: *** Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <NSCFArray: 0x396000> was mutated while being enumerated.' What's the best way to solve this? Well the way to solve it is not to mutate

I have a simple enum that I would like to iterate over. For this purpose, I've adopted Sequence and IteratorProtocol as shown in the code below. BTW, this can be copy/pasted to a Playground in Xcode 8. import UIKit enum Sections: Int { case Section0 = 0 case Section1 case Section2 } extension Sections : Sequence { func makeIterator() -> SectionsGenerator { return SectionsGenerator() } struct SectionsGenerator: IteratorProtocol { var currentSection = 0 mutating func next() -> Sections? { guard let item = Sections(rawValue:currentSection) else { return nil } currentSection += 1 return item } } }

I have a class called GenericPermutations that is both enumerable and an enumerator. Its job is to take an ordered list of objects and iterate through each permutation of them in order. Example, an integer implemenation of this class could iterate through the following: GenericPermutations<int> p = new GenericPermutations<int>({ 1, 2, 3 }); p.nextPermutation(); // 123 p.nextPermutation(); // 132 p.nextPermutation(); // 213 // etc. So its enumerable in the sense that it contains a 'list' of things you can enumerate over. It's also an enumerator, because its job involves finding the next

Having a following enumeration object ResponseType extends Enumeration { val Listing, Album = Value } How do I get a list of its vals? If you want to be thorough about this, you need to check that your symbols have Value as a supertype: def valueSymbols[E <: Enumeration: TypeTag] = { val valueType = typeOf[E#Value] typeOf[E].members.filter(sym => !sym.isMethod && sym.typeSignature.baseType(valueType.typeSymbol) =:= valueType ) } Now even if you have the following (which is perfectly legal): object ResponseType extends Enumeration { val Listing, Album = Value val someNonValueThing = "You don't

Perhaps someone can point me in the correct direction, because I'm completely stumped on this. I have a function that simply prints out a LinkedList of classes: LinkedList<Component> components = new LinkedList<Component>(); ... private void PrintComponentList() { Console.WriteLine("---Component List: " + components.Count + " entries---"); foreach (Component c in components) { Console.WriteLine(c); } Console.WriteLine("------"); } The Component object actually has a custom ToString() call as such: int Id; ... public override String ToString() { return GetType() + ": " + Id; } This function

I have a class that implements the Enumeration<T> interface, but Java's foreach loop requires the Iterator<T> interface. Is there an Enumeration to Iterator Adapter in Java's standard library? Bozho You need a so called "Adapter", to adapt the Enumeration to the otherwise incompatible Iterator . Apache commons-collections has EnumerationIterator . The usage is: Iterator iterator = new EnumerationIterator(enumeration); If you just want something to iterate over in a for-each loop (so an Iterable and not only an Iterator), there's always java.util.Collections.list(Enumeration<T> e) (without

I have a simple collections question. I have a Set<String> object. I want an enumeration of the strings in that set. What is the cleanest/best way to go about it? EDIT: There's no need to write your own (although I'll leave the implementation below for posterity) - see Kevin Bourrillion's answer for the one in the JDK. If you really need an enumeration, could could use: Enumeration<String> x = new Vector(set).elements(); It would be better to use Iterable<E> if at all possible though... A better alternative is to write a small wrapper class around Iterator<E> . That way you don't have to take