www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - How do I find the actual types of the elements in a list of classes?

reply "Jack Stouffer" <jack jackstouffer.com> writes:
Given:

--------------------
interface Parent {
         void method();
}

class A : Parent {
         void method() {}

         this() {}
}

class B : Parent {
         void method() {}
         void method2() {}

         this() {}
}

void main() {
         import std.stdio;

         Parent[] parent_list = [];
         parent_list ~= new A();
         parent_list ~= new B();

         foreach (item; parent_list) {
                 writeln(typeid(item));
         }
}
--------------------

With 2.068, it will output:

test.Parent
test.Parent

As far as I can tell, there is no way to know the actual type of 
each of the objects in the list to be able to print:

test.A
test.B

Are there any workarounds for this?

Also, this fails to compile when it doesn't look like it should:
--------------------
interface Parent {
         void method();
}

class A : Parent {
         void method() {}

         this() {}
}

class B : Parent {
         void method() {}
         void method2() {}

         this() {}
}

void main() {
         import std.stdio;

         Parent[] parent_list = [new A(), new B()];

         foreach (item; parent_list) {
                 writeln(typeid(item));
         }
}
--------------------


Thanks.
Aug 13 2015
parent reply "Adam D. Ruppe" <destructionator gmail.com> writes:
On Thursday, 13 August 2015 at 20:23:56 UTC, Jack Stouffer wrote:

 As far as I can tell, there is no way to know the actual type 
 of each of the objects in the list to be able to print:


Cast it to Object first, then do the typeid and it will get the 
dynamic class type. Since Parent is an interface, typeid works 
differently.

I wrote about this in more detail recently here:


it is a bit of a FAQ, but there's a solid reason behind the 
behavior.



 Also, this fails to compile when it doesn't look like it should:


I believe that's a well-known bug, the array literal tries to 
type it all to the first element instead of looking for the 
common types of all elements.

You could explicitly cast to the interface if you needed to, I 
believe just casting the first one will cause it to do the rest 
automatically.
Aug 13 2015
parent reply "Jack Stouffer" <jack jackstouffer.com> writes:
On Thursday, 13 August 2015 at 20:28:33 UTC, Adam D. Ruppe wrote:

 On Thursday, 13 August 2015 at 20:23:56 UTC, Jack Stouffer 
 wrote:

 As far as I can tell, there is no way to know the actual type 
 of each of the objects in the list to be able to print:


 Cast it to Object first, then do the typeid and it will get the 
 dynamic class type. Since Parent is an interface, typeid works 
 differently.

 I wrote about this in more detail recently here:



Thanks, that worked, and based on your answer, I was able to fix 
my real problem: dynamically calling different methods on each 
object in the list based on its type. So, using the above code as 
an example, I am able to call method if the object is of type A 
and method2 if the object is of type B:

interface Parent {
         void method();
}

class A : Parent {
         void method() {}

         this() {}
}

class B : Parent {
         void method() {}
         void method2() {}

         this() {}
}

void main() {
         import std.stdio;
         import std.string;

         Parent[] parent_list = [];
         parent_list ~= new A();
         parent_list ~= new B();

         foreach (item; parent_list) {
                 string class_name = (cast(Object) 
item).classinfo.name;
                 if (class_name == "test.A") {
                         (cast(A) item).method();
                 } else if (class_name == "test.B") {
                         (cast(B) item).method2();
                 }
         }
}

This is a dirty hack, but I don't care, it works :)
Aug 13 2015
next sibling parent reply Justin Whear <justin economicmodeling.com> writes:
On Thu, 13 Aug 2015 21:42:52 +0000, Jack Stouffer wrote:


          foreach (item; parent_list) {
                  string class_name = (cast(Object)
 item).classinfo.name;
                  if (class_name == "test.A") {
                          (cast(A) item).method();
                  } else if (class_name == "test.B") {
                          (cast(B) item).method2();
                  }
          }
 }
 
 This is a dirty hack, but I don't care, it works :)


Casting actually performs this check for you, returning null if the 
object can't be casted, so I'd do this:

foreach (item; parent_list) {
  if (auto asA = cast(A)item) {
    asA.method();
  } else if (auto asB = cast(B)item) {
    asB.method2();
  }
}
Aug 13 2015
parent "Jack Stouffer" <jack jackstouffer.com> writes:
On Thursday, 13 August 2015 at 22:20:35 UTC, Justin Whear wrote:

 foreach (item; parent_list) {
   if (auto asA = cast(A)item) {
     asA.method();
   } else if (auto asB = cast(B)item) {
     asB.method2();
   }
 }


On Thursday, 13 August 2015 at 22:20:35 UTC, Justin Whear wrote:

Thanks Justin and rumbu, that makes the code a lot more readable.
Aug 13 2015
prev sibling next sibling parent "rumbu" <rumbu rumbu.ro> writes:
On Thursday, 13 August 2015 at 21:42:54 UTC, Jack Stouffer wrote:


 Thanks, that worked, and based on your answer, I was able to 
 fix my real problem: dynamically calling different methods on 
 each object in the list based on its type. So, using the above 
 code as an example, I am able to call method if the object is 
 of type A and method2 if the object is of type B:

 interface Parent {
         void method();
 }

 class A : Parent {
         void method() {}

         this() {}
 }

 class B : Parent {
         void method() {}
         void method2() {}

         this() {}
 }

 void main() {
         import std.stdio;
         import std.string;

         Parent[] parent_list = [];
         parent_list ~= new A();
         parent_list ~= new B();

         foreach (item; parent_list) {
                 string class_name = (cast(Object) 
 item).classinfo.name;
                 if (class_name == "test.A") {
                         (cast(A) item).method();
                 } else if (class_name == "test.B") {
                         (cast(B) item).method2();
                 }
         }
 }

 This is a dirty hack, but I don't care, it works :)


It works as long as your module is called "test".

I think this is a better approach:

foreach (item; parent_list) {
         if (auto a = cast(A)item)
             a.method();
         else if (auto b = cast(B)item)
             b.method2();
     }
Aug 13 2015
prev sibling parent reply "Adam D. Ruppe" <destructionator gmail.com> writes:
On Thursday, 13 August 2015 at 21:42:54 UTC, Jack Stouffer wrote:

 dynamically calling different methods on each object in the 
 list based on its type.


The cleanest OO way of doing that is to put the methods you need 
in the interface and always call it through that. Then there's no 
need to cast and each child class can implement it their own way.
Aug 13 2015
parent reply "Jack Stouffer" <jack jackstouffer.com> writes:
On Thursday, 13 August 2015 at 22:49:15 UTC, Adam D. Ruppe wrote:

 On Thursday, 13 August 2015 at 21:42:54 UTC, Jack Stouffer 
 wrote:

 dynamically calling different methods on each object in the 
 list based on its type.


 The cleanest OO way of doing that is to put the methods you 
 need in the interface and always call it through that. Then 
 there's no need to cast and each child class can implement it 
 their own way.


This really doesn't make sense in the context that I am using 
this code in. The above code is a very reduced test case. In my 
code, the list can have 20-30 different types of classes in it 
all inheriting from the same interface, and it doesn't make sense 
for all of those classes to implement a method that is very 
specific to one of the classes.
Aug 13 2015
next sibling parent =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 08/13/2015 04:48 PM, Jack Stouffer wrote:

 On Thursday, 13 August 2015 at 22:49:15 UTC, Adam D. Ruppe wrote:

 On Thursday, 13 August 2015 at 21:42:54 UTC, Jack Stouffer wrote:

 dynamically calling different methods on each object in the list
 based on its type.


 The cleanest OO way of doing that is to put the methods you need in
 the interface and always call it through that. Then there's no need to
 cast and each child class can implement it their own way.


 This really doesn't make sense in the context that I am using this code
 in. The above code is a very reduced test case. In my code, the list can
 have 20-30 different types of classes in it all inheriting from the same
 interface, and it doesn't make sense for all of those classes to
 implement a method that is very specific to one of the classes.


Enter the visitor pattern (or its variant 'acyclic visitor pattern'). 
Although, with 20-30 classes, it will be nasty to use.. :( So, 
downcasting like suggested seems to be the best option here.

Ali
Aug 13 2015
prev sibling parent reply "Adam D. Ruppe" <destructionator gmail.com> writes:
On Thursday, 13 August 2015 at 23:48:08 UTC, Jack Stouffer wrote:

 In my code, the list can have 20-30 different types of classes 
 in it all inheriting from the same interface, and it doesn't 
 make sense for all of those classes to implement a method that 
 is very specific to one of the classes.



I don't want to get too far into this since I haven't seen your 
code, but the function that uses this list might itself be a 
candidate for addition to the interface, or a second interface 
with that method that all the classes also inherit from (remember 
you can only inherit from one class in D, but you can implement 
as many interfaces as you want).
Aug 13 2015
parent "Jack Stouffer" <jack jackstouffer.com> writes:
On Friday, 14 August 2015 at 00:06:33 UTC, Adam D. Ruppe wrote:

 On Thursday, 13 August 2015 at 23:48:08 UTC, Jack Stouffer 
 wrote:

 In my code, the list can have 20-30 different types of classes 
 in it all inheriting from the same interface, and it doesn't 
 make sense for all of those classes to implement a method that 
 is very specific to one of the classes.



 I don't want to get too far into this since I haven't seen your 
 code, but the function that uses this list might itself be a 
 candidate for addition to the interface, or a second interface 
 with that method that all the classes also inherit from 
 (remember you can only inherit from one class in D, but you can 
 implement as many interfaces as you want).


The code in question is a collision resolver in a 2D game that I 
am making. The list is a list of all of the drawable objects that 
the object could be colliding with. After collision is checked on 
each of the possible collisions, the object is placed at the last 
position where it was not colliding. I am using the cast in the 
enemy resolver where each collision is then checked to see if the 
collision was with the player, and if it was, the player is then 
given damage.

---------------------------------
class Blob : Enemy {
     ...

     final override void resolveCollisions() {
         import player : Player;

         //check for collision
         Entity[] possible_collisions = 
this.state_object.getPossibleCollisions(this);
         Entity[] collisions = [];

         foreach (ref entity; possible_collisions) {
             // discount any Rect that is equal to the player's, 
as it's probably
             // the players bounding box
             if (this.boundingBox != entity.boundingBox &&
                 this.boundingBox.intersects(entity.boundingBox)) {
                 collisions ~= entity;
             }
         }

         if (collisions.length > 0) {
             // If we collided with something, then put position 
back to its
             // original spot
             this.position = this.previous_position;

             // If we collided with the player, give the player 
damage
             foreach (collision; collisions) {
                 // Check to see if the object collided was a 
player by testing the
                 // result of the cast, which will return null if 
unsuccessful
                 if (auto player = cast(Player) collision) {
                     player.damagePlayer(5, this.position, 
this.mass);
                 }
             }
         }
     }
}
Aug 13 2015