[PHP] Modulaire Opzet

[Helmet]

Na enig zoekwerk op GOT, kwam ik de modulaire opzet van graasgast tegen. Deze opzet gaat uit van een Core klasse en een aantal subklasses die via het core object met elkaar moeten kunnen communiceren. (zie ook dit topic: [rml][ PHP] Extenden van een class (onb. naam)[/rml])

De opzet van deze code ziet er ongeveer zo uit:

PHP:

class myModule 
{
 var $core;
 // Constructor
 function myModule($core) 
 {
  # dit wordt niet uitgevoerd (waarom niet?)
  $this->core = &$core;
 }
}

/*
 Core class, intercommunication between the various modules
*/
class core  {
 // Clasvars
 var $db;
 var $dummy;
 var $modules = array();
 // Constructor
 function core() 
 {
  error_reporting(E_ALL);

  $this->modules[] = 'moddummy.class.php';
  $this->modules[] = 'moddb.class.php';
  
  foreach ($this->modules as $value) { require_once($value); } 
  $this->dummy = &new dummy($this);
  $this->db = &new db($this);
 }

 // mods_loaded()
 // returns an array with the modules currently loaded in the memory
 function mods_loaded() { return $this->modules; }
}

nu heb ik een aantal modules geschreven, en in principe zou ik in een module met $this->core->module_naam->functie_naam een functie uit een andere module moeten kunnen gebruiken. Ware het niet dat de constructor uit de module klasse volgens mij niet eens uitgevoerd wordt.

Een voorbeeld van mijn dummy module post ik hieronder:

PHP:

<?
 class dummy extends myModule 
 {
  var $testme;
  function dummy()
  {
   $this->testme = rand(1,10);
   echo 'mod_dummy is loaded!<br />
            it\'s now up to moddb.class.php to read my secret value :) 
           (should be: ' . $this->testme . ')<br />';
  }
  
  function secretvalue()
  {
   return $this->testme;
  }
 }
?>

waarom wordt de constructor-functie uit de klasse myModule niet behoorlijk uitgevoerd, en hoe krijg ik dan alsnog een reference naar mijn core object in de module?

[ Voor 28% gewijzigd door Helmet op 29-06-2004 21:31 ]

[chem]

http://nl2.php.net/language.oop.constructor

parent:: syntax

[Helmet]

Het is dus niet meer mogelijk met mijn huidige opzet?
want met de parent:: functie kom ik niet meer terug in de modules die door de core classe zijn geinitieerd

core::dummy::bla(); werkt dus niet naar behoren

[ Voor 64% gewijzigd door Helmet op 29-06-2004 22:49 ]

[Eärendil]

Je maakt een fout met references:

PHP:

class myModule {
  var $core;
  // Constructor
  function myModule($core) {
    $this->core = &$core;
  }
}

Je wilt een variable doorgeven by-reference aan de constructor van de module. Wat jij doet is een kopie van de variable doorgeven als parameter $core aan de functie, en dan verwijzen naar deze kopie.
Zo werkt het wel:

PHP:

class myModule {
  var $core;
  // Constructor
  function myModule(  &  $core) {
    $this->core = &$core;
  }
}

Hier geef je dus een reference mee als parameter. Zo staat het ook in het voorbeeld van GraasGast. Je moet de het hoofdstuk over references in de php-manual er maar eens op nalezen.

[Helmet]

Eärendil schreef op 30 juni 2004 @ 01:01:
Je maakt een fout met references:

PHP:

class myModule {
  var $core;
  // Constructor
  function myModule($core) {
    $this->core = &$core;
  }
}

Je wilt een variable doorgeven by-reference aan de constructor van de module. Wat jij doet is een kopie van de variable doorgeven als parameter $core aan de functie, en dan verwijzen naar deze kopie.
Zo werkt het wel:

PHP:

class myModule {
  var $core;
  // Constructor
  function myModule(  &  $core) {
    $this->core = &$core;
  }
}

Hier geef je dus een reference mee als parameter. Zo staat het ook in het voorbeeld van GraasGast. Je moet de het hoofdstuk over references in de php-manual er maar eens op nalezen.

Wat nog steeds niet verklaard waarom de constructor uit de functie module niet aangeroepen wordt, deze zou zelfs met die fout nog steeds aangeroepen moeten worden, maar een functie als echo of print_r wordt binnen de Constructor van de klasse MyModule nog niet uitgevoerd

[Eärendil]

Als ik het goed begrijp wil je dat de code uit de constructor van 'myModule' aangeroepen wordt in de constructor van 'dummy'?
Je moet dan in de constructor van 'dummy' de constructor van de parent aanroepen met:

parent::myModule($core)

waarbij &$core een parameter van de contructor van 'dummy' is.

[SchizoDuckie]

ik weet niet of je met PHP5 werkt, maar daar zit de geniale functie

PHP:

__autoload()

in...

Kijk daar eens naar zou ik zeggen, deze geeft je de mogelijkheid om automagisch niet-geinstantieerde objecten aan te maken

[chris]

Aan deze link heb je waarschijnlijk wel wat. Het zit namelijk zo: php roept alleen de constructor aan van de klasse dummy, maar niet automatisch die van de parent-class (myModule). Dit is opzich wel handig en logisch, stel dat jij in je dummy class de volgende constructor wil:

PHP:

dummy(&$core, $hello_message){
  echo $hello_message;
}

dan weet php natuurlijk niet automatisch dat 'ie de superclass moet aanroepen. en al helemaal niet met welke variabelen.

dus dan wordt het zoiets:

PHP:

dummy(&$core, $hello_message){
  echo $hello_message;
  parent::myModule($core);
}

[ Voor 12% gewijzigd door chris op 30-06-2004 12:12 ]

[Helmet]

Eärendil schreef op 30 juni 2004 @ 03:17:
Als ik het goed begrijp wil je dat de code uit de constructor van 'myModule' aangeroepen wordt in de constructor van 'dummy'?
Je moet dan in de constructor van 'dummy' de constructor van de parent aanroepen met:

parent::myModule($core)

waarbij &$core een parameter van de contructor van 'dummy' is.

deze code maakt het geheel werkend dank je wel

[Verwijderd]

chris schreef op 30 juni 2004 @ 12:09:dus dan wordt het zoiets:

PHP:

dummy(&$core, $hello_message){
  echo $hello_message;
  parent::myModule($core);
}

Hoewel het hier niet helemaal duidelijk is, kan je best altijd eerst de parent-constructor oproepen, en dan pas verder gaan met je eigen constructor. Hier maakt het uiteraard niets uit, maar in andere gevallen kan het best uitmaken (bijv. je gaat in de constructor van de derived class variabelen aanpassen die afhangen van variabelen uit de parent class: als je eerst gaat aanpassen (derived class) en dan pas initialiseren (base class) kan het wel eens mis gaan). Dus:

PHP:

dummy(&$core, $hello_message){
parent::myModule($core);
echo $hello_message;
}

In 'echte' prog.talen (bijv. java) is het trouwens verplicht om de constructor van de base class eerst aan te roepen. PHP controleert daar niet op, maar je kan het best doen

[ Voor 15% gewijzigd door Verwijderd op 30-06-2004 12:27 ]

[Oid]

...

[ Voor 100% gewijzigd door Oid op 13-05-2005 10:30 ]

[Verwijderd]

Je core klasse heeft geen lidvariabele $db, alleen $core. Probeer het eens met

PHP:

$core->core->set_database("localhost", "", "");

[ Voor 19% gewijzigd door Verwijderd op 05-07-2004 11:44 . Reden: opmaak ]

[Oid]

Verwijderd schreef op 05 juli 2004 @ 11:43:
Je core klasse heeft geen lidvariabele $db, alleen $core. Probeer het eens met

PHP:

$core->core->set_database("localhost", "", "");

Dan krijg ik de error:

Fatal error: Call to undefined function: set_connection() in /home/web26/domains/trkx.com/public_html/rotzooi/forum/includes/config.inc.php on line 16

Wat vanzelf spreken heel normaal is, want set_connection bestaat niet in de core class, echt er als ik eraan toevoeg: $core->core->db->set_connection(); krijg ik weer die oude error.

[Eärendil]

PHP:

$core = new module( &$core );

In deze regel gaat het mis, die klasse 'module' is helemaal niet bedoeld om direct te gebruiken, dat is een basisklasse die door alle modules gebruikt wordt. Verder geef je als argument &$core, terwijl je de variable $core helemaal niet bestaat.

PHP:

$core = new core()

Dit is waarschijnlijk wat je bedoelt.

Ik vraag me alleen af of het met globals niet veel makkelijker gaat.

[verytallman]

Ondanks dat dit een oud topic is, wou ik toch een reply geven.

Ik heb deze modulaire opzet namelijk ook gebruikt, maar ik snap niet waarom je gebruik zou moeten maken van de module "MyModule".

Zo kan het namelijk ook:

PHP:

class Core {
   var $DummyModule1;
   var $DummyModule2;
   function Core () {
      $this->DummyModule1 = new DummyModule1 ($this);
      $this->DummyModule2 = new DummyModule2 ($this);
   }
}


class DummyModule1 {
   var $core;
   function DummyModule1 (&$core) {
      $this->core = &$core;
      $this->core->DummyModule2->testDummy2();
   }
   function testDummy1(){
       echo 'hello';
   }
}

class DummyModule2 {
   var $core;
   function DummyModule2 (&$core) {
      $this->core = &$core;
      $this->core->DummyModule1->testDummy1();
   }
   function testDummy2(){
       echo 'hello';
   }
}

Nu kan je ook vanuit alle Modules andere Modules aanspreken. Werkt precies hetzelfde als met de (hulp)module "MyModule".

Het enige nadeel, en dat heb je ook als je gebruik maakt van "MyModule", is dat je niet in de constructor van een modules functies kan gaan aanroepen van andere modules, die later geladen worden in de Core.

Zo werkt testDummy2() wel, maar testDummy1() niet.

[4Real]

Hoe gaat dat nou eigenlijk met goed doorgeven van referenties?

Bij de functie moet er een & teken voor maar kun je daarna gewoon de referentie door geven of moet dat ook weer met een & teken?

PHP:

function do_something(&core)
{
    $this->core = $core;
}

// of

function do_something(&core)
{
    $this->core =& $core;
}

Ohja zal even kijk opzetje geven van mijn engine

PHP:

class engine
{
    // globale variablen hier
    private $_Database
    private $_Session


    private $_ActiveModule;
    private $_ListModule;

    public function init()
    {
        // ophalen van modules uit de database
        // module list wordt nu gevuld met
        // modulename, modulefilename, moduleurlname
        // moduleurlname geeft optie om de url dynamisch te maken
    }

    private function GetActiveModule()
    {
        //
        // kijken werke module er in de link staat
        // kijken of die bestaat
        //
    }

    private function GetActiveAction()
    {
        // ophalen van actie die in de link staat
        // of standaard actie in laden
    }

    private parse()
    {
        // module gegevens goed zetten
        // ActiveAction starten
    }
}

class Object
{
    protected $engine;
}

class ModuleBase extends Object
{
    private $_ModuleName
    private $_ModuleUrlName
    // nog zooi 

    public __construct(&engine)
    {
        $this->engine = $engine;
    }
}

class CustomModuleClass extends ModuleBase
{
    public __construct(&engine)
    {
        parent::__construct($engine);
        $this->engine = $engine;
    }

    // custom variabelen en functies hier in
    // 
    // ook paar standaard functies die vanuit de engine aangeroepen worden
}

Class ActionBase extends Object
{
    // zelfde principe als bij ModuleBase
    // base class voor standaad functies en methods

    public __construct(&engine)
    {
        $this->engine = $engine;
    }
}

class CustomActionClass extends ActionBase
{
    // zelfde idee als CustomModuleClass

    public __construct(&engine)
    {
        parent::__construct($engine);
        $this->engine = $engine;
    }
}

_{Dit is een ruwe opzet uit me hoofd in praktijk werkt het allemaal erg lekker}

[ Voor 77% gewijzigd door 4Real op 06-10-2006 08:25 ]