topic Re: Determine class name used for calling a static method in Application Development and Automation Discussions

Determine class name used for calling a static method

pokrakam — Wed, 15 Apr 2015 13:38:14 GMT

Hi all,

I know static methods cannot be redefined, but they can be called using a subclass as the 'calling class name'. Is it possible to determine the object type used for calling a static method?

For example, I have ZCL_SUPER with a static method HELLO and a subclass ZCL_SUB.

I can use ZCL_SUPER=>HELLO( ) or I can use ZCL_SUB=>HELLO( ).

Both will execute the same code (correct), but is it possible to tell the difference inside the HELLO method? SY-REPID will always show the superclass (also correct).

I've found some similar threads but none with a clear answer.

Any input appreciated,

Mike

Re: Determine class name used for calling a static method

nomssi — Wed, 15 Apr 2015 21:13:21 GMT

Hi Mike,

I have no solution either, what if the caller is not an object?

You can always evaluate the ABAP call stack (function module SYSTEM_CALLSTACK).

regards,

JNN

Re: Determine class name used for calling a static method

pokrakam — Thu, 16 Apr 2015 10:10:41 GMT

Hi Jacques,

Thanks for the input. Call stack won't help because it never shows inheritance, always the implementing class of a method. You can see this in the debugger. I also doublechecked with system debugging on, same result.

The only option there is to also go and parse the code of the calling program which adds more complexity than I'm trying to solve.

It doesn't really matter whether the caller is an object or a report, I want to know whether the line of code that invoked my static method used ZCL_SUPER=> or ZCL_SUB=>

Thanks,

Mike

Re: Determine class name used for calling a static method

rosenberg_eitan — Thu, 16 Apr 2015 10:39:48 GMT

Hi,

Just a thought....

If there was an ABAP equivalent to Java :

this.getClass().getName();

we can pass it as parameter .

Regards.

Re: Determine class name used for calling a static method

Tomas_Buryanek — Thu, 16 Apr 2015 10:53:32 GMT

I do not think it is possible. At least not with ABAP Objects "logic".

There is no reference to caller object ("me" does not exist in static method).

Maybe it is possible with some workaround. But for example SYSTEM_CALLSTACK would not help much with this problem, if you use local classes. I did not tried with global classes.

Re: Determine class name used for calling a static method

Tomas_Buryanek — Thu, 16 Apr 2015 10:59:15 GMT

There is equivalent reference "me" in ABAP and also cl_abap_classdescr. Problem is, that static method has no reference to "me".

Re: Determine class name used for calling a static method

Tomas_Buryanek — Thu, 16 Apr 2015 11:02:15 GMT

Is it possible to use instance method, or add parameter ZCL=>HELLO( "id_of_call" )?

Or it has to be static method without parameters?

Re: Determine class name used for calling a static method

rosenberg_eitan — Thu, 16 Apr 2015 11:04:15 GMT

Thanks.

I see there GET_CLASS_NAME

I did not test it.

Regards.

Re: Determine class name used for calling a static method

Tomas_Buryanek — Thu, 16 Apr 2015 11:58:08 GMT

cl_abap_classdescr=>get_class_name( me ) returns this:


\PROGRAM=ZTEST3\CLASS=ZCL_SUPER

or better to use longer call, but shorter result :

lref = cl_abap_classdescr=>describe_by_object_ref( me ).

lref->get_relative_name( ) which returns:


ZCL_SUPER

Re: Determine class name used for calling a static method

former_member205488 — Thu, 16 Apr 2015 12:35:34 GMT

Hello!

It's impossible to implement polymorphism using static methods in ABAP Objects. So, there is no difference between ZCL_SUPER=>HELLO( ) and ZCL_SUB=>HELLO( ) because you call exactly the same method in both cases

Re: Determine class name used for calling a static method

pokrakam — Thu, 16 Apr 2015 15:37:19 GMT

Thanks, but no then I'm stuck with the original problem of making every call explicit, or I might as well create statics in each subclass which call the superclass with the appropriate information.

Both of which are exactly what I'm trying to avoid - the developer should be able to call my method in a subclass they create and not worry about the rest.

Re: Determine class name used for calling a static method

naimesh_patel — Thu, 16 Apr 2015 16:50:14 GMT

Hi Mike,

Can I ask you why you want to know who called this method or by using what class name?

You can also call the static method with an instance of the class. If you pass this instance to this method, you can use the object descriptor to know the type of the object. Generally if that is the object you are working on, you are more likely to use that object reference to call the static method.

*
CLASS lcl_super DEFINITION.
PUBLIC SECTION.
CLASS-METHODS: hello IMPORTING io_obj TYPE REF TO lcl_super.
ENDCLASS.                    "lcl_super DEFINITION
*
CLASS lcl_sub DEFINITION INHERITING FROM lcl_super.
ENDCLASS.                    "lcl_sub DEFINITION

START-OF-SELECTION.
"lcl_sub=>hello( ).
DATA: lo_obj TYPE REF TO lcl_super.
CREATE OBJECT lo_obj.
lo_obj->hello( lo_obj ).
CREATE OBJECT lo_obj TYPE lcl_sub.
lo_obj->hello( lo_obj ).

lcl_super=>hello( lo_obj ).

*
CLASS lcl_super IMPLEMENTATION.
METHOD hello.
WRITE: / 'Im called'.

DATA: lo_objdesc TYPE REF TO cl_abap_objectdescr.
DATA: lv_name TYPE string.
lo_objdesc ?= cl_abap_objectdescr=>describe_by_object_ref( io_obj ).
lv_name = lo_objdesc->get_relative_name( ).
WRITE: lv_name.

ENDMETHOD.                    "hello
ENDCLASS.                    "lcl_super IMPLEMENTATION

Regards,

Naimesh Patel

Re: Determine class name used for calling a static method

pokrakam — Thu, 16 Apr 2015 21:27:08 GMT

Hi Naimesh,

Thanks for the input. Background is that this method is part of an abstract superclass, and it should manage how/what subclasses may be instantiated. So at the time of the call no instance of any sort is known to the caller.

The ideal 'OO way' would be a factory class returning an interface reference, but there's a long-winded reason for implementing the same idea in an inheritance tree with a static method at the top.

I did tinker around with having the top level class as a singleton instance, not too dissimilar form your idea. But that added more complexity for the caller so no joy there.

My current best approach is to use a standalone factory class with a separate method for each subclass in my tree that takes the input and adds the class name to the call to the static method in question.

Anyone who creates a subclass would have to create a corresponding factory method. Clunky but workable:

ZCL_OBJ_FACTORY=>GET_SUB1( somedata )

looks better than the really clunky:

ZCL_SUB1=>GET_INSTANCE( i_class = 'ZCL_SUB1' i_somedata = somedata ).

(which is now hidden in each factory method...)

I'll leave this open for ideas.

Thanks,

Mike

Re: Determine class name used for calling a static method

markus_lanz3 — Fri, 17 Apr 2015 08:12:57 GMT

Hi Mike

This is exactly one of the reasons why our team no longer works with static methods. Use an instance method instead, even if the coding is not (yet) object specific. This enables you also to use the runtime descriptor for classes to determine the actual name [cl_abap_classdescr=>get_class_name( me )]

Regards

Markus

Check this example:

class ZCL_SUPER definition
public
create public .
public section.
methods HELLO
returning
value(RV_NAME) type STRING .
protected section.
private section.
ENDCLASS.

CLASS ZCL_SUPER IMPLEMENTATION.
METHOD hello.
rv_name = cl_abap_classdescr=>get_class_name( me ).
ENDMETHOD.
ENDCLASS.

class ZCL_SUB definition
public
inheriting from ZCL_SUPER
create public .
public section.
protected section.
private section.
ENDCLASS.

CLASS ZCL_SUB IMPLEMENTATION.
ENDCLASS.

Program:

DATA: lo_obj TYPE REF TO zcl_sub.
DATA: lv_name TYPE string.

CREATE OBJECT lo_obj.

lv_name = lo_obj->hello( ).

WRITE lv_name.

Re: Determine class name used for calling a static method

naimesh_patel — Fri, 17 Apr 2015 14:12:11 GMT

Hey Mike,


Anyone who creates a subclass would have to create a corresponding factory method.

For FACTORY method, you should keep one method which gives the necessary object and hides the object creation complexity from the caller. Also, it should be out of your class hierarchy and into its own separate final class

This makes sure, there is only single-responsibility of the class
No confusion of how static method is called, as the class is final and there will not be any subclass for this class



My current best approach is to use a standalone factory class with a separate method for each subclass in my tree that takes the input and adds the class name to the call to the static method in question.

I think you should hide the class name from the caller - to decouple it. Instead, you should have a key which determines the class name. This key to class relationship could be defined

Using certain naming standards - e.g. ZCL_DOSOMETHING_ZK01 where ZK01 is my key
Using hardcoding the key and class relation in the method FACTORY
Using a table where you have the key and class relation

My preference is last option.

Using this option of the factory, the caller can easily obtain different objects for different keys without worrying about which specific method to be called to get which specific object.

Regards,

Naimesh Patel

Re: Determine class name used for calling a static method

pokrakam — Fri, 17 Apr 2015 19:03:25 GMT

Hi Naimesh,

Agree, as I explained, a standalone factory class is exactly what my current best-but-not-perfect approach is. Anyone who creates a subclass of main superclass also has to add a corresponding method to the factory class. The method name itself thus becomes the key, and inside it they need to pass the class name to the superclass.

If I add a further key into the equation then I'm back to where I might as well require all implementers of the class hierarchy to pass their subclass name in:

ZCL_SUB7=>GET_INSTANCE( i_class = 'ZCL_SUB7' i_otherstuff = stuff ).

I don't specifically want to hide the class name either. This is part of a larger framework where several developers will be creating subclasses, and these will be instantiated in various application scenarios. But in all cases the dev will know what they're trying to use.

This is exactly the type of reason interfaces are preferable to inheritance, but in this case I'm stuck with it.

Thanks,

Mike

Re: Determine class name used for calling a static method

pokrakam — Fri, 17 Apr 2015 19:59:24 GMT

Hi Markus,

Thanks for the input. Interesting idea of not using statics as a matter of policy.

I did play around with a couple of instance scenarios, but all those scenarios added even more complexity than the awkwardness I'm trying to eliminate. My problem (and the main reason for this setup) is to manage the instantiation - in some cases I will even get a different object back.

Some scenarios:

- Developer may want to evaluate which subclass to use.

- Developer may not care about the exact type and get a subclass of what s/he is requesting (polymorphic instantiation).

So completely without statics I would end up with stuff like:

DATA: myobj TYPE REF TO zcl_sub.

DATA: value TYPE i.

CREATE OBJECT myobj type zcl_sub_low. "pick the most likely sub-subtype to start with

value = myobj->my_static_check( somedata ).

if value < zcl_super=>threshold.

"Good, we got lucky

else.

"need different subclass

clear myobj.

create object myobj type zcl_sub_high.

endif.

or:

CREATE OBJECT myobj type zcl_sub_low.

classname = myobj->get_appropriate_class( ).

if classname <> myobj->get_classname( ).

clear myobj.

create myobj type (classname).

endif.

This is way too complex to do for every single instantiation of all the subclasses (there will be many!). So I'm trying to hide this type of logic in superclass statics and ideally have the developer just do:

if zcl_sub=>static_check( somedata ) <> abap_true.

"decide on which class to use

or:

myobj ?= zcl_sub=>get_instance( somedata ). "could return various subclasses of zcl_sub

Both very simple to do with a static method of zcl_sub, but I would like to implement it in zcl_super. This would be so simple if a static would know as which class it is being called...

Thanks,

Mike

Re: Determine class name used for calling a static method

nomssi — Sat, 18 Apr 2015 00:20:19 GMT

Hello Mike,

this looks like Abstract Factory to me, where you create a hierarchy of constructor classes in addition to your product hierarchy to have a stable object creation code:

lo_factory = lcl_factories=>get_instance( somedata ). " generates the appropriate factory object

lo_obj = lo_factory->new( somedata ). " generates the correct product

this could now be isolated in a static class if you use interfaces.

The price to pay is to to subclass lcl_factories and update its get_instance( ) method each time you add a product subclass.

best regards,

JNN

Re: Determine class name used for calling a static method

pokrakam — Mon, 20 Apr 2015 21:03:17 GMT

Hi Jacques,

That is indeed the best 'proper OO' solution to the scenario, although in my case I will end up with several factory classes.

In practice sadly it's too much work... I'm trying to create a framework which even junior developers want to use - a 3-lines-of-code job, which would ave been possible if a static method new it's calling mechanism.

I like the abstract factory idea but I'm not going to sell this one to the masses who still think a class is a new-fangled replacement for a function group.

To all who replied: I have been pleasantly surprised and impressed by the overall level of good quality input on this thread, thanks to for much food for thought.

Regards,

Mike

Re: Determine class name used for calling a static method

Richa_Gupta — Mon, 27 Apr 2015 04:31:46 GMT

Hi Mike,

As fas as I know, static method cannot be redefined in a subclass.

Now, if super class is an abstract class, then that means that static method also is an abstract method. This implies that super class should not call this method at all as there is no implementation of this method inside super class.

So, in a nutshell, if it is a usual super class, as the static methods cannot be redefined, so static method will always be called from super class only.

If it is an abstract super class, then as you cannot redefine the static method inside sub class, so what is the use of having it in super class.

Hope this helps!!!

Regards,

Richa