www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Iterating through enumeration

reply Alexandr Druzhinin <drug2004 bk.ru> writes:
Hello all.
I have some enum foo { first=1, second=2, fourth=4, sixth=6} and I'd 
like to go through this enumeration like it:
foreach(m; foo.min..foo.max) {
	bar(m);
}
But without excluding foo.max and correct handle situation when enum 
identifiers aren't consequentive.

Thanks in advance
Aug 12 2012
next sibling parent reply simendsjo <simendsjo gmail.com> writes:
On Sun, 12 Aug 2012 12:36:21 +0200, Alexandr Druzhinin <drug2004 bk.ru>  
wrote:

 Hello all.
 I have some enum foo { first=1, second=2, fourth=4, sixth=6} and I'd  
 like to go through this enumeration like it:
 foreach(m; foo.min..foo.max) {
 	bar(m);
 }
 But without excluding foo.max and correct handle situation when enum  
 identifiers aren't consequentive.

 Thanks in advance

Looking for this? http://dlang.org/phobos/std_traits.html#EnumMembers
Aug 12 2012
parent Alexandr Druzhinin <drug2004 bk.ru> writes:
12.08.2012 17:43, simendsjo пишет:
 On Sun, 12 Aug 2012 12:36:21 +0200, Alexandr Druzhinin <drug2004 bk.ru>
 wrote:

 Hello all.
 I have some enum foo { first=1, second=2, fourth=4, sixth=6} and I'd
 like to go through this enumeration like it:
 foreach(m; foo.min..foo.max) {
     bar(m);
 }
 But without excluding foo.max and correct handle situation when enum
 identifiers aren't consequentive.

 Thanks in advance

Looking for this? http://dlang.org/phobos/std_traits.html#EnumMembers

Aug 12 2012
prev sibling next sibling parent reply Jonathan M Davis <jmdavisProg gmx.com> writes:
On Sunday, August 12, 2012 17:36:21 Alexandr Druzhinin wrote:
 Hello all.
 I have some enum foo { first=1, second=2, fourth=4, sixth=6} and I'd
 like to go through this enumeration like it:
 foreach(m; foo.min..foo.max) {
 	bar(m);
 }
 But without excluding foo.max and correct handle situation when enum
 identifiers aren't consequentive.

foreach(m; std.traits.EnumMembers!foo) bar(m); Though be aware that since EnumMembers results in a TypeTuple, the foreach is actually done at compile time, meaning that you'd actually be getting bar(foo.first); bar(foo.second); bar(foo.fourth); bar(foo.sixth); Normally, that doesn't matter, but if you try and do fancier stuff, the fact that the foreach is executed at compile time could affect what you're doing, and if want your function to be small (e.g. inlining), then that would cause problems. - Jonathan M Davis
Aug 12 2012
next sibling parent Alexandr Druzhinin <drug2004 bk.ru> writes:
12.08.2012 17:45, Jonathan M Davis пишет:
 On Sunday, August 12, 2012 17:36:21 Alexandr Druzhinin wrote:
 Hello all.
 I have some enum foo { first=1, second=2, fourth=4, sixth=6} and I'd
 like to go through this enumeration like it:
 foreach(m; foo.min..foo.max) {
 	bar(m);
 }
 But without excluding foo.max and correct handle situation when enum
 identifiers aren't consequentive.

foreach(m; std.traits.EnumMembers!foo) bar(m); Though be aware that since EnumMembers results in a TypeTuple, the foreach is actually done at compile time, meaning that you'd actually be getting bar(foo.first); bar(foo.second); bar(foo.fourth); bar(foo.sixth); Normally, that doesn't matter, but if you try and do fancier stuff, the fact that the foreach is executed at compile time could affect what you're doing, and if want your function to be small (e.g. inlining), then that would cause problems. - Jonathan M Davis

Aug 12 2012
prev sibling next sibling parent Alexandr Druzhinin <drug2004 bk.ru> writes:
12.08.2012 18:23, Era Scarecrow пишет:
 On Sunday, 12 August 2012 at 10:45:37 UTC, Jonathan M Davis wrote:
 Though be aware that since EnumMembers results in a TypeTuple, the
 foreach is actually done at compile time, meaning that you'd actually
 be getting

 bar(foo.first);
 bar(foo.second);
 bar(foo.fourth);
 bar(foo.sixth);

 Normally, that doesn't matter, but if you try and do fancier stuff,
 the fact that the foreach is executed at compile time could affect
 what you're doing, and if want your function to be small (e.g.
 inlining), then that would cause problems.

But that problem goes away if you turn it into a small array right? (And pass the array to the foreach to cycle over) So throwing that idea out there you get... foo[] array; foreach(m; std.traits.EnumMembers!foo) array ~= m; foreach(m; array) { //not compiler-time expansion like above }

Aug 12 2012
prev sibling parent Timon Gehr <timon.gehr gmx.ch> writes:
On 08/12/2012 01:54 PM, bearophile wrote:
 Era Scarecrow:

 But that problem goes away if you turn it into a small array right?
 (And pass the array to the foreach to cycle over) So throwing that
 idea out there you get...

 foo[] array;

 foreach(m; std.traits.EnumMembers!foo)
 array ~= m;

 foreach(m; array) {
 //not compiler-time expansion like above
 }

Often better (but every time builds an array on the heap): foreach (m; [EnumMembers!Foo]) { // Not a static foreach } Bye, bearophile

This builds the array once at compile time: static immutable members = [EnumMembers!Foo]; foreach(m; members){ }
Aug 12 2012
prev sibling next sibling parent "Era Scarecrow" <rtcvb32 yahoo.com> writes:
On Sunday, 12 August 2012 at 10:45:37 UTC, Jonathan M Davis wrote:
 Though be aware that since EnumMembers results in a TypeTuple, 
 the foreach is actually done at compile time, meaning that 
 you'd actually be getting

 bar(foo.first);
 bar(foo.second);
 bar(foo.fourth);
 bar(foo.sixth);

 Normally, that doesn't matter, but if you try and do fancier 
 stuff, the fact that the foreach is executed at compile time 
 could affect what you're doing, and if want your function to be 
 small (e.g. inlining), then that would cause problems.

But that problem goes away if you turn it into a small array right? (And pass the array to the foreach to cycle over) So throwing that idea out there you get... foo[] array; foreach(m; std.traits.EnumMembers!foo) array ~= m; foreach(m; array) { //not compiler-time expansion like above }
Aug 12 2012
prev sibling next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
Era Scarecrow:

  But that problem goes away if you turn it into a small array 
 right? (And pass the array to the foreach to cycle over) So 
 throwing that idea out there you get...

 foo[] array;

 foreach(m; std.traits.EnumMembers!foo)
     array ~= m;

 foreach(m; array) {
  //not compiler-time expansion like above
 }

Often better (but every time builds an array on the heap): foreach (m; [EnumMembers!Foo]) { // Not a static foreach } Bye, bearophile
Aug 12 2012
prev sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
Timon Gehr:

 This builds the array once at compile time:

 static immutable members = [EnumMembers!Foo];
 foreach(m; members){

 }

Right: import std.traits; enum Foo { A, B, C, D, E, F } int main() { static immutable members = [EnumMembers!Foo]; int count = 0; foreach (m; members) count++; foreach (m; members) count++; return count; } __Dmain: push EAX xor EAX, EAX xor EDX, EDX cmp _D4temp4mainFZi7membersyAE4temp3Foo, EAX je L17 LD: inc EAX inc EDX cmp EDX, _D4temp4mainFZi7membersyAE4temp3Foo jb LD L17: xor EDX, EDX cmp _D4temp4mainFZi7membersyAE4temp3Foo, EDX je L2B L21: inc EAX inc EDX cmp EDX, _D4temp4mainFZi7membersyAE4temp3Foo jb L21 L2B: pop ECX ret Bye, bearophile
Aug 12 2012