Stronger typing, require array where param array

[quix0rs-gnu-social.git] / classes / Managed_DataObject.php

diff --git a/classes/Managed_DataObject.php b/classes/Managed_DataObject.php
index 7990d7f40891fb0a6559062f35a1f77c4dfa24fd..e957e7ba8f505a120c4ab45dbce668ce2bfae121 100644 (file)
--- a/classes/Managed_DataObject.php
+++ b/classes/Managed_DataObject.php
@@ -30,6 +30,69 @@ abstract class Managed_DataObject extends Memcached_DataObject
      */
     public static abstract function schemaDef();
 
+    /**
+     * Get an instance by key
+     *
+     * @param string $k Key to use to lookup (usually 'id' for this class)
+     * @param mixed  $v Value to lookup
+     *
+     * @return get_called_class() object if found, or null for no hits
+     *
+     */
+    static function getKV($k,$v=NULL)
+    {
+        return parent::getClassKV(get_called_class(), $k, $v);
+    }
+
+    /**
+     * Get an instance by compound key
+     *
+     * This is a utility method to get a single instance with a given set of
+     * key-value pairs. Usually used for the primary key for a compound key; thus
+     * the name.
+     *
+     * @param array $kv array of key-value mappings
+     *
+     * @return get_called_class() object if found, or null for no hits
+     *
+     */
+    static function pkeyGet(array $kv)
+    {
+        return parent::pkeyGetClass(get_called_class(), $kv);
+    }
+
+    /**
+     * Get multiple items from the database by key
+     *
+     * @param string  $keyCol    name of column for key
+     * @param array   $keyVals   key values to fetch
+     * @param array   $otherCols Other columns to hold fixed
+     *
+     * @return array Array mapping $keyVals to objects, or null if not found
+     */
+       static function pivotGet($keyCol, array $keyVals, array $otherCols=array())
+       {
+           return parent::pivotGetClass(get_called_class(), $keyCol, $keyVals, $otherCols);
+       }
+
+    /**
+     * Get a multi-instance object
+     *
+     * This is a utility method to get multiple instances with a given set of
+     * values for a specific key column. Usually used for the primary key when
+     * multiple values are desired.
+     *
+     * @param string $keyCol  key column name
+     * @param array  $keyVals array of key values
+     *
+     * @return get_called_class() object with multiple instances if found, or null for no hits
+     *
+     */
+    static function listGet($keyCol, array $keyVals)
+    {
+        return parent::listGetClass(get_called_class(), $keyCol, $keyVals);
+    }
+
     /**
      * get/set an associative array of table columns
      *
@@ -38,9 +101,7 @@ abstract class Managed_DataObject extends Memcached_DataObject
      */
     function table()
     {
-        // Hack for PHP 5.2 not supporting late static binding
-        //$table = static::schemaDef();
-        $table = call_user_func(array(get_class($this), 'schemaDef'));
+        $table = static::schemaDef();
         return array_map(array($this, 'columnBitmap'), $table['fields']);
     }
 
@@ -93,6 +154,7 @@ abstract class Managed_DataObject extends Memcached_DataObject
     function keyTypes()
     {
         $table = call_user_func(array(get_class($this), 'schemaDef'));
+        $keys = array();
 
         if (!empty($table['unique keys'])) {
             foreach ($table['unique keys'] as $idx => $fields) {
@@ -151,4 +213,54 @@ abstract class Managed_DataObject extends Memcached_DataObject
 
         return $style;
     }
-}
\ No newline at end of file
+
+    function links()
+    {
+        $links = array();
+
+        $table = call_user_func(array(get_class($this), 'schemaDef'));
+
+        foreach ($table['foreign keys'] as $keyname => $keydef) {
+            if (count($keydef) == 2 && is_string($keydef[0]) && is_array($keydef[1]) && count($keydef[1]) == 1) {
+                if (isset($keydef[1][0])) {
+                    $links[$keydef[1][0]] = $keydef[0].':'.$keydef[1][1];
+                }
+            }
+        }
+        return $links;
+    }
+
+    /**
+     * Return a list of all primary/unique keys / vals that will be used for
+     * caching. This will understand compound unique keys, which
+     * Memcached_DataObject doesn't have enough info to handle properly.
+     *
+     * @return array of strings
+     */
+    function _allCacheKeys()
+    {
+        $table = call_user_func(array(get_class($this), 'schemaDef'));
+        $ckeys = array();
+
+        if (!empty($table['unique keys'])) {
+            $keyNames = $table['unique keys'];
+            foreach ($keyNames as $idx => $fields) {
+                $val = array();
+                foreach ($fields as $name) {
+                    $val[$name] = self::valueString($this->$name);
+                }
+                $ckeys[] = self::multicacheKey($this->tableName(), $val);
+            }
+        }
+
+        if (!empty($table['primary key'])) {
+            $fields = $table['primary key'];
+            $val = array();
+            foreach ($fields as $name) {
+                $val[$name] = self::valueString($this->$name);
+            }
+            $ckeys[] = self::multicacheKey($this->tableName(), $val);
+        }
+        return $ckeys;
+    }
+}