Include a class from within another?

heliumflash01

Hey, all -

Just wondering if it's possible to conditionally include a class from within the function of another class. From within an external function, it's no problem...but of course you can't define a class within another one. Is there any way to externalize the include?

Basically, each function within the main class may need another class to instantiate an object or something. But I only want to include each class if a function is called that requires it. Is it possible at all?

Thanks!

-Jeremy

mithril

Actually, you can instantiate a class within another class. Just call the source files for all your classes at the outset of the script (not within class methods... though that is also possible) and create all the class instances with the wrapper class's constructor. This is much more effiecient since you only need to include the source file once, remember that due to the restrictions of classes and variable scope you'd need to recall the same source file in each function. By doing it in the constructor you can create class level objects for each of the sub-classes then reference them (saves memory overall). For example:

<?php

  class cWrapper {

    var $objContainer;

    function cWrapper ()
    {
      $this->objContainer = array();

      if (class_exists("cDatabase")) {

        $db = &new cDatabase();
        $this->Register("cDatabase", $db);
      }

      if (class_exists("cShoppingCart")) {

        $cart = &new cShoppingCart();
        $this->Register("cShoppingCart", $cart);
      }

      // etc........
    }

    function Register($type, $handler)
    {
      $this->objContainer[$type] = $handler;
    }
  }

  $obj = &new cWrapper();
?>

For a working example of this type of wrapper class, check out the database abstraction layer I use on my site:

http://www.mithril.ca/code/php/lib_db_abstraction.php

HTH.

geoff

heliumflash01

Geoff -

Thanks for your help on this. I apologize, too, for taking a while to get back to you. Really what I'm looking for is the second scenario that you say is possible, calling the source files from within the functions of another class. When I do an require() or include(), I've got to hit the filesystem and have PHP bring the file in, which could be for a great many files if I do it all at the outset. Therefore, I want to require() each file only if it's going to be used.

To make sure I don't grab the same source file more than once, I generally use require_once(). Will that still work in the scenario you alluded to?

-Jeremy

mithril

Jeremy,

require_once() or include_once() will work if called within a class. Using a wrapper class, I suppose it's possible to get around it by placing the require_once() calls in the wrapper..... but it strikes me as being inefficient and more trouble than the disc access savings are worth from a code maintainablity point of view. Instead, use require() or include() calls in the "header section" of your scripts instead. Couple reasons for saying that....

First, nesting conditional include calls leads very quickly to unmaintainable code. It's easy enough to understand now when you're actively writing the project, but come back 3 months later and it won't seem quite so familiar or logical.

Second, there was a very interesting point raised at a recent PHP Users Group meeting I attended.... "Pre-optimization is the root of all evil". Basically in trying to optimize your code while you're writing it you often create code which more bloated and boggy than it would have been otherwise.

I'd suggest writing the app calling the all potentially needed include files at the script header (like #<include beer.h> calls in C) then, once the app performs properly, worrying about trying to optimize the number of disc access calls. If you're only calling 4 or 5 files conditional includes are not going to make much, if any, noticeable difference anyways. If you're calling a large enough number of included files to make a difference, there's the root of the problem anyways. Try merging related files to reduce calls.

My third reason for saying that goes back to my previous comment about class scope. As you know, the *_once() functions build a table of files already called which they compare all subsequent calls against to make sure a file is included only once. Now, image you have two separate classes (neither extends the other) which under a given set of circumstances will both need a file. Using require_once(), the first class to be called will get the file and a reference to the file will be entered in said table. When the second class tries to call the file, require_once() will read it as having already been called and ignore the call. Since the included file's functions, variables, etc. will be restricted to the scope of the first class, the second class won't know that they exist.

Another way of approaching what you're talking about would be to use GET or POST vars to determine the conditions the script will experience. For example, continuing on with a shopping cart example (and again in the script header):

  <?php

    if (isset($purchaseItems)) {

      require_once("cart_checkout.inc");
    }

    else if (isset($addItem) || isset($removeItem)) {

      require_once("cart_maintainence.inc");
    }

    //...........

This kind of conditional include is obviously much easier to maintain since it's not buried with class and function structure.

HTH.

geoff