Creating system objects...

Lord_Yggdrasill

Well in Java and Javascript there are system built-in objects accessible in any scope of the script. Some examples are System, Math in Java and Window, Document in Javascript. The good thing about these objects is that they can be accessed from both main script and functions/classes methods.

In PHP, however, I will have to declare such variables(database, page, template for instance) to be global in every function/method that uses it. The other approach is to inject dependency, but these are technically 'global' objects that are used in almost 50% of the functions/methods. The script will have to look like this below, quite tedious if you ask me:

$system = new System;
$database = new Database($dsn, $dbuser, $dbpass);
$page = new Page($system->getpage());
$template = new Template($system->gettemplate());

class Someclass{

  public function __construct($arg1, $arg2...){
     global $database, $page, $template;
     // constructor code inside
  }

  public function somemethod($arg1, $arg2...){
     global $database, $page;
     // code inside
  }

  public function anothermethod($arg1, $arg2...){
     global $database, $templage;
     // code inside
  }

  // And more...
}

Sure I can define a database, page and template handler method for this class so that I only declare global variables once. Nonetheless, it is still tedious if I have like tens of classes like this. Note the idea of registering $GLOBALS is not acceptable since its insecure and poor programming practice...

So the question is, are there easier and more convenient ways to define system objects that can be used in any scope of the script: main script, function files, class files or whatever. Please lemme know if you can help, and Id appreciate every single line of comment. Thanks.

Derokorian

Why not use the singleton pattern?

class database {
   private $_instance;

   private function __construct() {
      $this->conn = new mysqli($params);
   }

   public static function getInstance() {
      return self::$_instance ?: self::$_instance = new database();
   }
}

class someClass {
   public function __construct() {
      $this->db = database::getInstance();
   }
}

class someClass2 {
   public function __construct() {
      $this->db = database::getInstance();
   }
}

Lord_Yggdrasill

umm maybe this can be used for page and template, thanks for the advice. I will look into it although this will inevitably result in an argument in my dev team as most of the programmers believe singleton is bad and should never be used...

The database is not really a unique object, however. My software has integration over MyBB forum, in which the forum database is instantiated as another database object. In future it may have integration with other third party databases from applications such as flashchat, oekaki and wordpress. What should I do if I want all of the database objects to be accessible in class methods/functions? o_o

Derokorian

most of the programmers believe singleton is bad and should never be used...

I don't know how you can say singleton is bad and then be doing:

function myFunc($args) {
   global $vars;
}

The database is not really a unique object, however. My software has integration over MyBB forum, in which the forum database is instantiated as another database object. In future it may have integration with other third party databases from applications such as flashchat, oekaki and wordpress. What should I do if I want all of the database objects to be accessible in class methods/functions?

Easy! Simply extend the class with the unique connection overwriting the construct.

class BBDatabase extends Database {
   // Overwrite construct with this DB's credentials
   private function __construct() {
      include CONFIG . 'database.php';
      $cfg = $config['database']['BB'];
      $this->conn = new mysqli($cfg['host'],$cfg['user'],$cfg['pass'],$cfg['name']);
   }
} 
class FlashChatDatabase extends Database {
   // same here overwrite with this unique connection
   private function __construct() {
      include CONFIG . 'database.php';
      $cfg = $config['database']['FlashChat'];
      $this->conn = new mysqli($cfg['host'],$cfg['user'],$cfg['pass'],$cfg['name']);
   }
}
// etc.... 
$bbdb = BBDatabase::getInstance();
$fcdb = FlashChatDatabase::getInstance();

var_dump($bbdb,$fcdb); // Different instances!

You could even write an instance based singleton almost....

<?php

class Database {
   private static $_instances = array();

   private function __construct($name) {
      include CONFIG . 'database.php';
      $cfg = $config['database'][$name];
      $this->conn = new mysqli($cfg['host'],$cfg['user'],$cfg['pass'],$cfg['name']);
   }

   public static function getInstanceOf($name) {
      return isset(self::$_instances[$name]) ? self::$_instances[$name] : self::$_instances[$name] = new Database($name);
   }
}

$db = Database::getInstanceOf('Local1');
$db2 = Database::getInstanceOf('Local2');

When I tested this my config file looked like:

<?php

$config = array();
$config['database'] = array();

$config['database']['Local1'] = array();
$config['database']['Local1']['host'] = 'localhost';
$config['database']['Local1']['user'] = '---';
$config['database']['Local1']['pass'] = '----';
$config['database']['Local1']['name'] = 'test';

$config['database']['Local2'] = array();
$config['database']['Local2']['host'] = 'localhost';
$config['database']['Local2']['user'] = '---';
$config['database']['Local2']['pass'] = '----';
$config['database']['Local2']['name'] = 'test2';

Lord_Yggdrasill

Thanks for showing me the example, I am going to try that out and see how it works. It seems that I should create a config class, but that will be done later. XD

Derokorian

Yeah, but I wasn't trying to show all the workings as you may have noticed there is also no error checking of any kind but I was just trying to get the point across. Again since you actually end up with more than one database object if you have more than one database to connect to, i'm not sure if it still qualifies for a singleton - but this is a pattern I've begun using and it has simplified a great many parts of my applications to use it.

However if you find a better way than the almost singleton pattern, then I would ask you to share it so I can learn too!

Lord_Yggdrasill

No worries, I hope I can but if advanced programmers like you cant find a better way than Singleton there is not a good chance intermediates like me could. I will see what I can do though, lately I've been receiving helps from some professionals in my neighborhood to further improve my skills.

There is still one problem left though. Lets say the four objects $database, $currentuser, $page, and $template are all singleton objects from their corresponding class. If I use the Singleton approach as you suggested, the code will look like this:

class Database {
   private static $_instances = array();

   private function __construct($name) {
      // Constructor code for Database
   }

   public static function getInstanceOf($name) {
      return isset(self::$_instances[$name]) ? self::$_instances[$name] : self::$_instances[$name] = new Database($name);
   }
}

class Page {
   private static $_instances = array();

   private function __construct($name) {
      // Constructor code for Page
   }

   public static function getInstanceOf($name) {
      return isset(self::$_instances[$name]) ? self::$_instances[$name] : self::$_instances[$name] = new Page($name);
   }
}

class Template {
   private static $_instances = array();

   private function __construct($name) {
      // Constructor code for Template
   }

   public static function getInstanceOf($name) {
      return isset(self::$_instances[$name]) ? self::$_instances[$name] : self::$_instances[$name] = new Template($name);
   }
}

Note I am not building a CurrentUser class since it will be generated using the UserCreator class from abstract factory pattern. But anyway the problem is clear as the code can get quite tedious:

class someClass {
   public function __construct() {
      $this->db = database::getInstance();
      $this->currentuser = UserCreator::getcurrentuser();
      $this->page = page::getInstance();
      $this->template = template::getInstance();
   }
}

class someClass2 {
   public function __construct() {
      $this->db = database::getInstance();
      $this->currentuser = UserCreator::getcurrentuser();
      $this->page = page::getInstance();
      $this->template = template::getInstance();
   }
}

which can get even longer with more objects like this. I personally aint sure if it is a good idea to assign every singleton object as class property. But otherwise we will have to assign these singleton objects to a local variable in class method tens or hundreds of times, this requires quite a bit of typing if you ask me.

So what do you think? Is there a better way to handle this multiple singleton/global object issue? Just wondering.

NogDog

A compromise might be to create one object that is simply a repository for other objects. Then you pass that one container object to each individual object that needs access to one or more of its contained objects. It can also be a container for simple data that needs to be accessed by many different objects (e.g. sanitized form data?).

Lord_Yggdrasill

I see, this does sound like a good solution. I sorta created a core class for my project already, it looks like this below:

<?php

class System{
  // The core class for my project

  const version = "1.3.2";
  const vercode = 132;
  public $path; 
  public $db;
  public $cookies;
  public $session;
  public $currentuser;
  public $settings;
  public $page;
  public $template;
  public $request;
  public $input;
  public $plugin;
  public $debug = FALSE;

  public function __construct(){
     // The initialization of this script

 $this->db = $this->loaddb();
 $this->cookies = $this->getcookies();
 $this->session = $this->getsession();
 $this->currentuser = $this->getcurrentuser();
 $this->setting = $this->getsettings();
 $this->page = $this->getpage();
 $this->input = $this->parseinput();
  }

  public function checkversion(){
     $versions = trim(file_get_contents("http://www.domainname.com/version.txt"));
	 $versions = explode(",", $versions);
	 if(!in_array(self::vercode, $versions)) $version = "Custom Version";
	 elseif(self::vercode < $versions[0]) $version = "Outdated Version";
	 else $version = "Latest Version";
     return $version;	 
  }

  public function locatepath(){
     // Will be added in future	 
  }  

  public function loaddb(){
     if(!file_exists("../inc/config.php")) throw new Exception("Could not find config file.");
  	 try{
        $this->db = new PDO(DSN, DBUSER, DBPASS);
     }
     catch(PDOException $pe){
        die("Could not connect to database, the following error has occurred: <br><b>{$pe->getmessage()}</b>");  

     }
  }

  public function getcookies(){
     if(!class_exists('Cookies')) throw new Exception('Cannot load class Cookies.');
	 return new Cookies(); 
  }

  public function getsession(){
     if(!class_exists('Session')) throw new Exception('Cannot load class Session.');
	 return new Session();
  }

  public function getcurrentuser(){
     if(!interface_exists('Creator')) throw new Exception('Cannot load interface Creator.');
	 if(!class_exists('UserCreator')) throw new Exception('Cannot load abstract class UserCreator');
     $creator = (UserCreator::logincheck())?new MemberCreator($this->cookies->mysuid):new VisitorCreator($_SERVER['REMOTE_ADDR']);
	 $user = $creator->create();
	 return $user;
  }

  public function getsettings(){
     return globalsettings();
  }

  public function getpage($page = ""){
     $page = secure($page);
     return new Page($page);
  }

  public function gettemplate(){
     // Will be added later
  }

  public function checkrequest(){
     // This method checks if there is user input, and returns the request_method if evaluated to be true
     if($_SERVER['REQUEST_METHOD'] == "POST"){
  	    $this->request = "post";
		return TRUE;
	 }	
	 elseif($_SERVER['REQUEST_METHOD'] == "GET"){
	    $this->request = "get";
		return TRUE;
	 }	
	 else return FALSE;
  }

  public function parseinput(){
     // This method parses inputs with the secure() function, which will be enhanced in future releases

 if(!$this->checkrequest()) $inputobj = "";
 if($this->request == "post") $input = array_map('secure',$_POST);
 if($this->request == "get") $input = array_map('secure',$_GET);

 // Now convert our beloved input array to object
 if(!empty($input)) $inputobj = new ArrayObject($input, ArrayObject::ARRAY_AS_PROPS);
 return $inputobj;
  }

  public function loadcrons(){
     // Will be added in future
  }

  public function loadplugins(){
     // Will be added in future
  }

  public function displayerror($error){
     // Display generic error that
	 switch($error){
	    case "register":
		   $this->page->settitle($lang_dupaccount_title);
		   $this->page->addcontent($lang_dupaccount);
		   break;
	    case "login":
		   $this->page->settitle($langislog);
		   $this->page->addcontent($langislogfull);
	       break;
        case "guest":
  		   $this->page->settitle($accden);
		   $this->page->addcontent($reqlogin);
	       break;         		
   		case "id":
		   $this->page->settitle($err_idnoexist);
		   $this->page->addcontent($err_idnoexist_text);
		   break;
		case "action":
		   $this->page->settitle($lang_invalidact_title);
		   $this->page->addcontent($lang_invalidact);
           break;
        case "session":
		   $this->page->settitle($lang_session_expired_title);
		   $this->page->addcontent($lang_session_expired);
           break;
        case "noaccess":
		   $this->page->settitle($lang_file_noaccess_title);
		   $this->page->addcontent($lang_file_noaccess);
           break;	
        default:
           $this->page->settitle("Error");
		   $this->page->addcontent("An error has occurred.");  		
	 }
  }

  public function output(){
     echo $this->page->showpage();
  }
}

So you'd recommend me to make a singleton object out of this system class, and load it into whatever class methods that need it?

NogDog

It does not necessarily have to be a singleton, but it's certainly a viable option. If you instantiate it in the main script and then pass it in to the constructors of the objects that need it, you may not have any need to use it as a singleton. But if that is too unwieldy within your app design, then you could consider the singleton option. (For that matter, even if you define it as a singleton, there is nothing stopping you from treating it as if it is not a singleton and passing it from script to object to object.

Lord_Yggdrasill

I see, I understand. The reason why I raised this question in the first place was that I didnt like the approach of declaring a global variable for system object. I did think about passing it as argument in class method, but about 50% of the methods use them so dependency injection may not work out.

Another issue is that if the state of this system object is changed inside a class method, this change will not be carried over when I use system object outside of class method. This was why I used global variable in the first place(though I dont like this approach tbh). Is there a good way you can think of to resolve this problem?

NogDog

Lord Yggdrasill;11005576 wrote:
...
Another issue is that if the state of this system object is changed inside a class method, this change will not be carried over when I use system object outside of class method. This was why I used global variable in the first place(though I dont like this approach tbh). Is there a good way you can think of to resolve this problem?

Not really: since PHP 5.0, objects are passed as references by default. Therefore, any object you pass into any constructor or other method's parameter list will be passed by reference, and thus any change you make to that object will be "seen" by any other object/method you've passed it to.

<?php

class Test
{
	public $something = 0;
}

class Foo
{
	public $test;
	public function __construct(Test $test)
	{
		$this->test = $test;
	}
}

class Bar extends Foo {}

$test = new Test;
$foo = new Foo($test);
$bar = new Bar($test);

echo $foo->test->something . "<br />\n";   // 0
echo $bar->test->something . "<br />\n";   // 0
echo $test->something . "<br />\n";        // 0

$foo->test->something = 5;

echo $foo->test->something . "<br />\n";   // 5
echo $bar->test->something . "<br />\n";   // 5
echo $test->something;                     // 5
//

laserlight

NogDog wrote:
Not really: since PHP 5.0, objects are passed as references by default. Therefore, any object you pass into any constructor or other method's parameter list will be passed by reference, and thus any change you make to that object will be "seen" by any other object/method you've passed it to.

More accurately, since PHP 5.0, object variables are actually reference variables in that they refer to the object instead of containing the object. The difference between this and PHP references is subtle, but you can read more in PHP manual's entry on objects and references. (If you are familiar with C, you can understand them as limited pointers without pointer syntax.)

Lord_Yggdrasill

Thanks, guess I completely missed the point before. I was wondering though, what if the change is made inside a class rather than outside of it? Here is a possible script I can come out with(the System::$page is a singleton object):

class System{
   public static $page;

   public static function getpage(){
       // return the page object
   }
}

class PageModifier{
   public function modify($title, $content){
       $page = System::getpage();
       $page->title = $title;
       $page->content = $content;
       echo $page->title;
       echo $page->content;      

   }
}

$title = "A title";
$content = "Some content";
$modifier = new PageModifier();

// Now outout the title and content for the page using modifier
$modifier->modify($title, $content);

// And how about this one? Is it the same as the last result?
echo System::$page->title;
echo System::$page->content;

In this script the page title and content are modified inside the PageModifier class, which prints title and content out using modify() method. This change, however, is carried out inside a PageModifier object, not from outside of the class. In this case, will the changes made in PageModifier::modify() method be carried over to the singleton object System::$page? Please lemme know if you dont mind, thanks.

laserlight

Lord Yggdrasill wrote:
This change, however, is carried out inside a PageModifier object, not from outside of the class. In this case, will the changes made in PageModifier::modify() method be carried over to the singleton object System::$page?

Yes, it will. The different context does not make a difference here. The key is that you are not assigning to $page from within the modify member function. Rather, you are assigning to $page->title and $page->content, which means that you are actually changing the object that $page refers to, and that object is the same one that System::$page refers to.

Lord_Yggdrasill

@ Laserlight:

Thank you so much. Guess it is safe to assume that it will work out too if I use getter and setter methods to access/assign values to a page object(if the title and content properties are private/protected)?

I am thinking about assigning every global objects to a system class, which acts like a storage of objects that are being used in other classes/objects. According to Nogdog this is better than declaring globals or using superglobal arrays.

laserlight

Lord Yggdrasill wrote:
Guess it is safe to assume that it will work out too if I use getter and setter methods to access/assign values to a page object?

Yes. That said, why not write a test script to experiment? 🙂

Lord Yggdrasill wrote:
I am thinking about assigning every global objects to a system class, which acts like a storage of objects that are being used in other classes/objects. According to Nogdog this is better than declaring globals or using superglobal arrays.

The idea of using a class (or if you prefer, a namespace) to group singletons together is fine. However, consider a database connection: for now, it might be obvious that you are going to have a single database connection and that it must be globally accessible. But if you're writing a component that is fairly generic, then it might not be wise to use this database connection singleton, because then your generic component will be tightly coupled to the specifics of your application.

Lord_Yggdrasill

I understand. In fact the Database class itself is not a singleton class, at least not from my script thus far. What I am doing is to assign a specific database object to the System singleton class, so that it can be used anywhere in the script, even within classes and functions. It is still possible to instantiate other database objects(such as a forum database when a MyBB/PhpBB bridge is made), but these wont be statically available throughout the script. Similarly for the CurrentUser object, which is basically a special instance of the User object stored in System class.

The Page class though, is more suitable as a unique object that should only be instantiated once. I'd prevent any attempts to instantiate other page objects using singleton if necessary.