public static function singleton($classname) { if (!isset(self::$instance)) { self::$instance = new $classname(); } return self::$instance; }
function test_find_by() { setup_sqlite_test_db(); # PHP 5.3 needed to call magic methods statically, so # work around by instanciating the class as singleton $Test = Singleton::instance("Test"); # create two test entries to be found Test::create(array("dummy" => "Test 1"), array("dummy" => "Test 2")); # Test find_by single id $dummy = $Test->find_by_id(1); $this->assertEqual(strtolower(get_class($dummy)), "test"); $this->assertEqual($dummy->dummy, "Test 1"); # Test find_by id array $dummies = $Test->find_by_id(array(1, 2), array("order" => "id")); $this->assertEqual(count($dummies), 2); $this->assertEqual($dummies[0]->dummy, "Test 1"); $this->assertEqual($dummies[1]->dummy, "Test 2"); # Test it works with strings, too $dummy = $Test->find_by_dummy("Test 2"); $this->assertEqual($dummy->id, 2); # Test their combination $dummy = $Test->find_by_id_and_dummy(1, "Test 1"); $this->assertEqual($dummy->id, 1); $this->assertEqual($dummies[0]->dummy, "Test 1"); # Test their array'ed combination $dummies = $Test->find_by_id_and_dummy(array(1, 2), array("Test 1", "Test 2"), array("order" => "id")); $this->assertEqual(count($dummies), 2); $this->assertEqual($dummies[0]->dummy, "Test 1"); $this->assertEqual($dummies[1]->dummy, "Test 2"); }
function test_sti_field_is_saved_and_used_correctly() { setup_sqlite_test_db(); # Create a dummy test entries $dummy = Test::create(array("dummy" => "TestDummy")); $this->assertEqual($dummy->type, NULL); $stest = new SuperTest(array("dummy" => "SuperDummy")); $stest->save(); $this->assertEqual(strtolower($stest->type), "supertest"); $utest = new UltraTest(array("dummy" => "UltraDummy")); $utest->save(); $this->assertEqual(strtolower($utest->type), "ultratest"); $atest = new AutoTest(array("dummy" => "AutoDummy")); $atest->save(); $this->assertEqual(strtolower($atest->type), "autotest"); # PHP 5.3 needed to call magic methods statically, so # work around by instanciating the class as singleton $Test = Singleton::instance("Test"); # Load and check test entries $dummy2 = $Test->find_by_dummy("TestDummy"); $this->assertEqual($dummy2->type, NULL); $this->assertEqual(strtolower(get_class($dummy2)), "test"); $stest2 = $Test->find_by_dummy("SuperDummy"); $this->assertEqual(strtolower($stest2->type), "supertest"); $this->assertEqual(strtolower(get_class($stest2)), "supertest"); $utest2 = $Test->find_by_dummy("UltraDummy"); $this->assertEqual(strtolower($utest2->type), "ultratest"); $this->assertEqual(strtolower(get_class($utest2)), "ultratest"); $atest2 = $Test->find_by_dummy("AutoDummy"); $this->assertEqual(strtolower($atest2->type), "autotest"); $this->assertEqual(strtolower(get_class($atest2)), "autotest"); }
public static function get_instance() { if (!isset(self::$instance)) { self::$instance = new static(); } return self::$instance; }
public static function getInstance() { if (!self::$instance instanceof self) { self::$instance = new Singleton(); } return self::$instance; }
public static function get_instance() { if (!self::$instance) { self::$instance = new self(); } return self::$instance; }
public static function getInstance() { if (self::$instance == null) { self::$instance = new self(); } return self::$instance; }
public static function getInstance() { if (empty(self::$instance)) { self::$instance = new self(); } return self::$instance; }
static function getInstance() { if (empty(self::$instance)) { self::$instance = new Singleton(); } return self::$instance; }
public static function getInstance() { if (is_null(self::$instance)) { self::$instance = new Singleton(); } return self::$instance; }
public static function GetInstance() { if (Singleton::$instance == null) { Singleton::$instance = new Singleton(); } return Singleton::$instance; }
public static function getInstance() { if (!isset(self::$instance)) { $c = __CLASS__; self::$instance = new $c(); } return self::$instance; }
public static function getInstance() { if (empty($instance)) { self::$instance = new Singleton(); self::$instance->loadValues(); } return self::$instance; }
static function instance() { if (!isset(self::$instance)) { $c = get_called_class(); self::$instance = new $c(); } return self::$instance; }
public static function getInstance() { if (!self::$instance) { self::$instance = new self(); echo 1; return self::$instance; } }
public static function singleton() { if (!isset(self::$instance)) { echo 'Creating new instance.'; $className = __CLASS__; self::$instance = new $className(); } return self::$instance; }
public static function getInstance() { if (!isset(self::$instance)) { self::$instance = new self(); echo "<p>First initialization</p>"; } else { echo "<p>initialization</p>"; } return self::$instance; }
public function connection($dbName) { if (self::$instance == null) { self::$instance = new \mysqli(DBHOST, DBUSER, DBPASSWD, $dbName); if (self::$instance->connect_errno > 0) { die('Unable to connect to database [' . self::$instance->connect_error . ']'); } } return self::$connection; }
function &find() { # instantiate model singleton for scoping $model =& Singleton::instance($this->_source); # wrap finder into model scope $options = func_get_args(); $model->with_find_scope($this->_wrap_scope["find"]); $result = $this->_source->find($options); $model->end_scope(); return $result; }
public function __construct() { if (!self::$instance) { self::$instance = $this; echo 'New Instance<br>'; return self::$instance; } else { echo 'Old Instance'; return self::$instance; } }
public static function getInstance() { if (self::$instance === null) { self::$instance = new self(); $xmlstr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<errors/>"; if (self::$xml === null) { self::$xml = new \SimpleXMLElement($xmlstr); self::$xml->addChild("error", "500"); self::$xml->addChild("description", "Internal Server Error"); self::$stacktraces = self::$xml->addChild("stacktraces"); } } return self::$instance; }
public function testSingleton() { $singleton = Singleton::instance(); $singleton2 = Singleton::instance(); $this->assertTrue($singleton === $singleton2); }
function has_one($what, $options = array()) { $table = Inflector::tableize($what); $assoc_class = Inflector::classify($table); $assoc_model = Singleton::instance($assoc_class); $default_options = array("class_name" => $assoc_class, "primary_key" => $assoc_model->_primary_key, "foreign_key" => Inflector::underscore($this->_base_class) . "_id", "dependent" => "nullify", "select" => "*", "validate" => true); $options = array_merge($default_options, $options); $this->_has_one = array_merge($this->_has_one, array($what => $options)); }
function &find($arguments) { $conditions = array(); # Be sure to have arguments in an array as needed below if (!is_array($arguments)) { $arguments = array($arguments); } # Instantiate model singleton to access scope $model =& Singleton::instance(); $scope = $model->_scope["find"]; $where = $order = $limit = $offset = NULL; $options = array(); # preset scoped options if (isset($scope["order"])) { $order = $scope["order"]; } # flatten all arguments if their key is numeric # this resolves e.g. array(1, 2, array("conditions" => "foo")) into array(1, 2, "conditions" => "foo") while (true) { $break = true; foreach ($arguments as $key => $value) { if (is_numeric($key) && is_array($value)) { unset($arguments[$key]); $arguments = array_merge_recursive($arguments, $value); $break = false; break; } } if ($break) { break; } } # parse arguments into query parameters foreach ($arguments as $key => $arg) { if (is_numeric($key)) { switch ($arg) { case "all": $limit = $offset = NULL; $options[] = $arg; continue 2; case "first": $limit = 1; $offset = NULL; $options[] = $arg; continue 2; default: $key = $this->_primary_key; } } switch ($key) { case "conditions": # FIXME make this DRY (see also AdoDBRecord_AssociationProxy) if (!is_array($arg)) { $arg = array($arg); } $conditions = array_merge_recursive($conditions, $arg); break; case "limit": case "offset": case "order": ${$key} = $arg; break; default: if (is_array($arg)) { $conditions[] = sprintf("{$key} IN (?)", $arg); } else { $conditions[] = array("{$key} = ?", $arg); } } } # parse conditions $parsed_conditions = array(); $parsed_params = array(); AdoDBRecord_Tools::parse_conditions($conditions, $parsed_conditions, $parsed_params); # join scoped conditions if (!empty($scope["conditions"])) { $parsed_conditions[] = $scope["conditions"]; } # convert parsed options to sql if ($order !== NULL) { $order = " ORDER BY {$order}"; } if (!empty($parsed_conditions)) { $where = sprintf(" WHERE (%s)", join($parsed_conditions, ") AND (")); AdoDBRecord_Tools::convert_sql_params($where, $parsed_params); } $objs = array(); $conn =& _adodb_conn(); # FIXME re-add table and column quotes again later if ($limit === NULL) { $limit = -1; } if ($offset === NULL) { $offset = -1; } if ($rs =& $conn->SelectLimit("SELECT * FROM {$this->_table_name}{$where}{$order}", $limit, $offset, $parsed_params)) { $rows =& $rs->GetRows(); foreach ($rows as $row) { $class = empty($row["type"]) ? get_class($this) : $row["type"]; $obj = new $class($row); $obj->_new_record = false; $objs[] = $obj; } if (in_array("all", $options)) { return $objs; } if (in_array("first", $options)) { return $objs[0]; } if (count($objs) == 1) { return $objs[0]; } return $objs; } $objs = NULL; return $objs; }
public static function getInstance() { if (!self::$instance) { self::$instance = new self(); } }
public function instance() { return Singleton::instance('process'); }
function &inflections() { return Singleton::instance("Inflections"); }
function ®istration() { return Singleton::instance(__CLASS__); }
public static function getInstance() { self::$instance !== null ?: (self::$instance = new self()); return self::$instance; }
$this->plural("/{$s01d}(?i){$s1rest}\$/", $p01d . $p1rest); $this->singular("/{$p01u}(?i){$p1rest}\$/", $s01u . $s1rest); $this->singular("/{$p01d}(?i){$p1rest}\$/", $s01d . $s1rest); } } function uncountable($words) { if (!is_array($words)) { $words = array($words); } foreach ($words as $word) { $this->uncountables[] = $word; } } } $inflect =& Singleton::instance("Inflections"); $inflect->plural('/$/', 's'); $inflect->plural('/s$/i', 's'); $inflect->plural('/(ax|test)is$/i', '\\1es'); $inflect->plural('/(octop|vir)us$/i', '\\1i'); $inflect->plural('/(alias|status)$/i', '\\1es'); $inflect->plural('/(bu)s$/i', '\\1ses'); $inflect->plural('/(buffal|tomat)o$/i', '\\1oes'); $inflect->plural('/([ti])um$/i', '\\1a'); $inflect->plural('/sis$/i', 'ses'); $inflect->plural('/(?:([^f])fe|([lr])f)$/i', '\\1\\2ves'); $inflect->plural('/(hive)$/i', '\\1s'); $inflect->plural('/([^aeiouy]|qu)y$/i', '\\1ies'); $inflect->plural('/(x|ch|ss|sh)$/i', '\\1es'); $inflect->plural('/(matr|vert|ind)(?:ix|ex)$/i', '\\1ices'); $inflect->plural('/([m|l])ouse$/i', '\\1ice');