[RESOLVED] Automatically defining static 'factory' methods

[evan_k]

From a base class, I want to have 'factory' static methods that would instantiate other classes:

// should return a new instance of class_one
base_class::class_one();

// should return a new instance of class_two
base_class::class_two();

I'm currently doing this by explicitly writing each of these static methods in the base class, but I'm estimating anywhere from ten to fifty of these identical methods for different classes.

class base_class {
  static function class_one() {
    return new class_one();
  }
  static function class_two() {
    return new class_two();
  }
}

I can't help but think that there has to be a better way...Is there?

[dougal85]

I have to wonder what the point in this factory class is. Since its doing nothing more than the new keyword anyway... I'm not really sure what you are trying to achieve.

The only way I can think of is as shown below. Required PHP5 as it uses the magic method __get. You can't use it with a static call however, so it may not be what you want...

<?php

class base_class{

public function __get($name){

	if(class_exists($name)){

		return new $name;

	} else {

		// invalid class name - deal with how you want here

	}


}

}

class TestClass{


}

$x = new base_class();

$testClassInstance = $x->TestClass;

var_dump($testClassInstance);

[dougal85]

I'll throw this one out there for you too...

<?php

class base_class{

static function get($name){

	if(class_exists($name)){

		return new $name;

	} else {

		// invalid class name - deal with how you want here

	}


}

}

class TestClass{


}

$testClassInstance = base_class::get("TestClass");

var_dump($testClassInstance);

[evan_k]

Well, it's basically a set of classes all under a common namespace, and in the use of it, the constructors will be called A LOT. as such, simply allowing a way to remove the new keyword will save a substantial amount of time, effort, and coding space.

This is how it would look as is:

$i = new base_one(
	new base_one(
		new base_two(
			new base_three($a),
			$b
		)
	),
	new base_one(
		new base_two(
			new base_three($c),
			$d
		),
		new base_two(
			new base_three($e),
			$f
		),
		new base_two(
			new base_three($g),
			$h
		),
	)
);

And this is along the lines of how I would like to clean it up:

$i = base::one(
	base::one(
		base::two(
			base::three($a),
			$b
		)
	),
	base::one(
		base::two(
			base::three($c),
			$d
		),
		base::two(
			base::three($e),
			$f
		),
		base::two(
			base::three($g),
			$h
		),
	)
);

After you pointed me to magic functions, I found __call(), but it seems that doesn't work with static methods, so I may use them all as non-static public methods of an instantiated base class object:

$i = $o->one(
	$o->one(
		$o->two(
			$o->three($a),
			$b
		)
	),
	$o->one(
		$o->two(
			$o->three($c),
			$d
		),
		$o->two(
			$o->three($e),
			$f
		),
		$o->two(
			$o->three($g),
			$h
		),
	)
);

I think this will work pretty well afterall. Thanks 🙂

[dougal85]

Seems like a rather crazy structure to me. I do wonder what your trying to model. However, I'll assume you know better than me on this one since I don't know the context of it all beyond 'one' 'two' and 'three'.

Anyway - if this is resolved, remember to mark the thread resolved under the thread tools at the top.

[evan_k]

Unfortunately, the only way I can accomplish my goal is through some kind of horrific interface, heh.

I'm trying to assemble a function-based MySQL query-building library. The goal is to have something that the frontend devs can reuse to automate and/or loop the process of assembling SQL commands, and without worrying about tainted values, column names, table names, etc.

Thanks again for the help!