// Place 1 (foobar.class.php)
$object = Foo::factory(1);


// Do stuff..


------


// Place 2 (min.class.php)
$object = Foo::factory(1);


// Do stuff..



-----


class Foo {


 static function factory($id) {
  // Return instance (and create it first if it wasn't requested before)
 }


}

class Foo {


	protected	$foo	= 0;
	protected	$id		= 0;
	
	function __construct($id) {
	
		$this->id	= $id;
	
	}
	
	function set($x) {
		$this->foo	= $x;
	}
	
	function get() {
		return $this->foo;
	}


}

class Foo extends FooPool {


	protected	$foo	= 0;
	protected	$id		= 0;
	
	function __construct($id) {
	
		self::load($this, $id);
		$this->id	= $id;
	
	}
	
	function set($x) {
		$this->foo	= $x;
	}
	
	function get() {
		return $this->foo;
	}


}


class FooPool {


	private static $values	= array();
	
	// only set this when you want to, you don't need it
	private static $vars	= array();
	private static $set		= false;
	
	static function load($object, $id) {
		// If the ID is 0, return (because there is nothing to cache)
		if ($id == 0) {
			return;
		}
		
		// If the object is not an instance of us, throw an exception
		if (!($object instanceof self)) {
			throw new Exception('object does not extend me :(');
		}
		
		// If we don't know the variables, get variables
		if (!self::$set) {
			self::$vars	= get_object_vars($object);
			self::$set	= true;
		}
		
		// If we don't have this id set, set it in the values array
		if (!isset(self::$values[$id])) {
			self::$values[$id]	= self::$vars;
		}
		
		// now set a reference to very variable in the array
		foreach (self::$values[$id] as $name => $value) {
			$object->$name	= &self::$values[$id][$name];
		}
		
	}
	


}

$classone	= new Foo(1);
$classtwo	= new Foo(1);
$classthree	= new Foo(2);


// Set classone:foo to 50 and echo classone, classtwo and classthree
$classone->set(50);


echo $classone->get()."\n";			// Prints 50
echo $classtwo->get()."\n";			// Prints 50
echo $classthree->get()."\n";		// Prints 0


$classtwo->set(60);


echo $classone->get()."\n";			// Prints 60
echo $classtwo->get()."\n";			// Prints 60
echo $classthree->get()."\n";		// Prints 0


$classthree->set(80);


echo $classone->get()."\n";			// Prints 60
echo $classtwo->get()."\n";			// Prints 60
echo $classthree->get()."\n";		// Prints 80

// basic pool class
class Pool {


	// This array contains every value of every class.
	private static $values	= array();
	
	// This array contains the variable names of classes.
	private static $vars	= array();
	
	// This array determines what classes are already known.
	private static $set		= array();
	
	
	static function load($object, $id) {
		// If the ID is 0, return (because there is nothing to cache)
		if ($id == 0) {
			return;
		}
		
		// Get class name
		$classname	= get_class($object);
		
		// If we don't know the class yet get variables and initialize values array
		if (!isset(self::$set[$classname])) {
			self::$vars[$classname]		= get_object_vars($object);
			self::$set[$classname]		= true;
			self::$values[$classname]	= array();
		}
		
		// If we don't have this id set, set it in the values array
		if (!isset(self::$values[$classname][$id])) {
			self::$values[$classname][$id]	= self::$vars[$classname];
		}
		
		// now set a reference to very variable in the array
		foreach (self::$values[$classname][$id] as $name => $value) {
			$object->$name	= &self::$values[$classname][$id][$name];
		}
		
	}
	


}

-- Lua implementation of pooling idea


Foo	= {}
Foo.values	= {}
function Foo:new(id)


	if (Foo.values[id] == nil) then
		Foo.values[id]	= setmetatable({}, {__index = Foo});
	end
	
	return Foo.values[id]


end



classone	= Foo:new(1)
classtwo	= Foo:new(1)
classthree	= Foo:new(2)


print(classone)
print(classtwo)
print(classthree)