2

I have two classes that I use to access two different tables in my db. They both have a similar constructor that looks like that:

function __construct($db) {
    $this->db = $db;
    $userDAO = DAO_DBrecord::createUserDAO($this->db);
    $this->userDAO = $userDAO;
}

The other class has the same constructor except that it uses createOtherTableDAO($this->db).

I am planning on having a couple other such classes, and it would be convenient if I could have them all inherit the same constructor, and pass createAppropriateTableDAO as an argument.

To clarify, in the first case above, createUserDAO($this->db) is a static function that calls a constructor in my DAO class. The function in the DAO looks as follows:

public static function createUserDAO($db) {
    return new DAO_DBrecord($db, 'users');
}

I use this method to make sure the user model can only call a DAO on the users table.

I'm somewhat of a beginner, and I don't think I have ever seen anything like what I want.

hakre
  • 193,403
  • 52
  • 435
  • 836
JDelage
  • 13,036
  • 23
  • 78
  • 112

4 Answers4

2

Move the code to create the DAOs into a Factory and then inject the DAOs instead of hard coupling them into whatever these classes are supposed to represent. Or rather create the various Table Data Gateways ("classes that I use to access two different tables") as a whole in the Factory, e.g.

class TableDataGatewayFactory
…
    public function create($gatewayName)
    {
        switch ($gatewayName) {
            case 'user':
                return new TableDataGateway(new UserDao($this->db)));
                break;
            default:
                throw new Exception('No Gateway for $gatewayName');
        }
    }
}

As for $this->db, either pass that into the Factory via the ctor or move the creation into the Factory as well. It's somewhat doubled responsibility, but tolerable given that this Factory revolved around creating Database related collaborator graphs.

Apart from that: yes, call_user_func(array('ClassName', 'methodName')) would work. See the manual for

Gordon
  • 312,688
  • 75
  • 539
  • 559
  • @JDelage: Check [this](http://en.wikipedia.org/wiki/Factory_method_pattern) out. There is a PHP example there, as well. – FtDRbwLXw6 Feb 13 '12 at 13:44
  • Why not simply put a switch statement inside the parent class? – JDelage Feb 13 '12 at 14:37
  • @JDelage Because Creation should be separated from the Collaborators. It improves coupling and cohesion. See http://misko.hevery.com/2008/08/21/where-have-all-the-singletons-gone – Gordon Feb 13 '12 at 20:09
1

To answer your question first: No, you can't (without resorting to evilCode) pass a function name as a parameter. But: What you want to archive is a poster-child-issue for an object oriented approach using inheritance.

You'd need a base-class:

class BaseClass
{    
    function __construct($db) {
        $this->db = db;
    }    
}

and your implementations :

class MyClass extends BaseClass
{
    function __construct($db) {
        parent::__contruct($db);
        $this->userDAO = DAO_DBrecord::createUserDAO($this->db);
    }
}

Just for the record: the evilCode would have been a) you could encapsulate your function in a create_function that can be used as an argument. b) you could pass the function name as a string to your function and then pass it to eval in the receiving function.

But remember: When eval or create_function looks like the answer you're probably asking the wrong questions!

See: related question

Community
  • 1
  • 1
Nicktar
  • 5,548
  • 1
  • 28
  • 43
  • 1
    The use of eval isn't required when passing a string as a function name. – CBusBus Feb 13 '12 at 14:05
  • Why not simply put a `switch` in the parent class constructor and pass a string to decide which dao to use? Would that violate "open - closed principle"? – JDelage Feb 13 '12 at 14:45
  • Also, I am not clear on the benefit of writing `parent::_construct($db)` in the child constructor. Why not simply write `$this->db=$db` (and we don't need the parent constructor at all). That's actually how I have my code right now, but I was hoping to simplify it by having a single constructor in a parent class (and none in the children). – JDelage Feb 13 '12 at 14:52
  • 1
    @JDelage I was expecting you code snippets to be simplified examples and a hierarchy of more than two (or very few) subclasses. With a constructor that simple and only two subclasses an inheritance-based approach is slightly over engineered apart from my personal preferences and the educational value. When your subclasses have more in common than their constructor it might make sense to use inheritance but nothing should keep you from using a switch for your two cases. – Nicktar Feb 14 '12 at 15:27
1

There are several methods which you can use if you feel it necessary to pass the function name or indeed the function itself as a parameter of a function.

call_user_func($function,$args);

call_user_func is one of Php's native functions for invoking methods or functions which takes a function name and optional arguments parameter.

The functionality of call_user_func (when not pertaining to object methods) can be replicated without the using call_user_func using a variable with the string literal of the function name. For example:

function some_func()
{
  echo "I'm a function!";
}

$function = "some_func";
$function();    /*Output: I'm a function!*/

And if you're feeling adventurous you can go a bit further and pass a closure / anonymous function as instead of the function name. For example:

$function = function()
{
    echo "I'm another function!";
}

$function();    /*Output: I'm another function*/
CBusBus
  • 2,321
  • 1
  • 18
  • 26
0

You can achieve such behavior by using:

jacekmigacz
  • 789
  • 12
  • 22