How to parameterize initialization of controllers

Question

Say we have a controller <i>A_ctrl</i> and a model <i>A_model</i>. When initializing <i>A_ctrl</i> we would like to create/register the model and initialize it, something like:
A_model ?= create_model( class_name = '/path/toclass' model_id = me->model_id ).
A_model->set_something( me->some_parameter ).
Now, as one can see the initialization is parameterized with <i>me->model_id</i> and <i>me->some_parameter</i> ; since <i>do_init()</i>'s signature is empty, instance variables of <i>A_ctrl</i> are used.
However, how do we get the initialization parameters into <i>A_ctrl</i> (in non-BSP ABAP-OO the normal constructor would do the job)? In the view via <bsp:call>, <bsp:parameter> it is to late, because initialization has already taken place. If we don't initialize the model and leave this job (i.e. calling the methods <i>set_something()</i> etc.) to the creator of <i>A_ctrl</i> (probabely the super controller) itself, we would actually hold the creator of an object responsible for its correct/complete initialization - a job that objects typically are supposed do themselves (in 'normal' OO this is the one right to exist for constructors (right?)).
How is this dilemma solved?
Regards,
Sebastian

Answer 1

Now we're talking Hello Max, hello Rainer, let me check whether I got the last paragraph of Max's reply right. In (super-)controller A you create and initialize (sub-)controller B's model (using the model's constructor or dedicated init-methods) and only then you let B register its (now initialized) model:
A, do_init():
b  = create_controller( name = 'B.do' id = 'b' ).
bm = create object b_model
       exporting
         someInitParameter  = ..
         someOtherParameter = ..
         owner = me .
b->set_model( bm ).
Hmm.. works and looks better. One has to be careful though that the code of the constructor contains a line if_bsp_model~init( id, owner ) where owner would be controller A.
In the meantime I found a solution that extends this:
Let me generalize the situation, say we want to create a generic component (~ controllermodelview) called 'tree' - and of course we want this component to be save, i.e. - topic of this thread - controller/model initialize themselves in a proper (OO-)way.
Now every user (other controller) of this component has to implement an interface 'tree_user' which contains a set of setter-methods. These setter-methods each get a reference to the tree-controller (and function as call-backs on the actual setter-methods on the tree-controller). Example:
do_init() of tree-ctrl:
DATA:
  parent     TYPE REF TO /namespace/if_tree_user,
  tree_model TYPE REF TO /namespace/cl_tree_model.
  parent ?= me->m_parent.
  parent->set_tree_title( me ).
  parent->set_tree_id( me ).
  parent->set..
  CREATE OBJECT tree_model
    EXPORTING
      im_tree_id   = me->tree_id
  set_model( model_id = me->model_id model_instance = tree_model ).
The controller that uses the tree component and that implements the interface now implements the setter-methods like
im_tree_ctrl->set_tree_title( 'OrgStructure' ).
etc.
E voilà, the do_init() of this controller now only contains something like
create_controller( controller_name = 'tree_ctrl.do' controller_id = 'org_struct_ctrl' ).
the actual initialization of tree controller/model is where it belongs (in the do_init()/constructor of tree_ctrl or tree_model respectively, not outside) and it is a compile-time error if a user of the component does not implement the tree_user interface!
Of course the user controller still has to implement the setters in a sensible way (here call back the setters of tree_ctrl itself), but this much one can expect.
Whatya think, from an OO point of view I am very satisfied now , would it be worth it writing a weblog about this?
Regards,
Sebastian