Upload files to 'classes'

classes/bencodetorrent.class.php

@@ -1,158 +1,170 @@
-<?
+<?php
 /**
  * Torrent class that contains some convenient functions related to torrent meta data
  */
-class BencodeTorrent extends BencodeDecode {
-  private $PathKey = 'path';
-  public $Files = [];
-  public $Size = 0;
+class BencodeTorrent extends BencodeDecode
+{
+    private $PathKey = 'path';
+    public $Files = [];
+    public $Size = 0;
 
-  /**
-   * Create a list of the files in the torrent and their sizes as well as the total torrent size
-   *
-   * @return array with a list of files and file sizes
-   */
-  public function file_list() {
-    if (empty($this->Dec)) {
-      return false;
-    }
-    $InfoDict =& $this->Dec['info'];
-    if (!isset($InfoDict['files'])) {
-      // Single-file torrent
-      $this->Size = (Int64::is_int($InfoDict['length'])
-        ? Int64::get($InfoDict['length'])
-        : $InfoDict['length']);
-      $Name = (isset($InfoDict['name.utf-8'])
-        ? $InfoDict['name.utf-8']
-        : $InfoDict['name']);
-      $this->Files[] = array($this->Size, $Name);
-    } else {
-      if (isset($InfoDict['path.utf-8']['files'][0])) {
-        $this->PathKey = 'path.utf-8';
-      }
-      foreach ($InfoDict['files'] as $File) {
-        $TmpPath = [];
-        foreach ($File[$this->PathKey] as $SubPath) {
-          $TmpPath[] = $SubPath;
+    /**
+     * Create a list of the files in the torrent and their sizes as well as the total torrent size
+     *
+     * @return array with a list of files and file sizes
+     */
+    public function file_list()
+    {
+        if (empty($this->Dec)) {
+            return false;
+        }
+        $InfoDict =& $this->Dec['info'];
+        if (!isset($InfoDict['files'])) {
+            // Single-file torrent
+            $this->Size = (Int64::is_int($InfoDict['length'])
+            ? Int64::get($InfoDict['length'])
+            : $InfoDict['length']);
+            $Name = (isset($InfoDict['name.utf-8'])
+            ? $InfoDict['name.utf-8']
+            : $InfoDict['name']);
+            $this->Files[] = array($this->Size, $Name);
+        } else {
+            if (isset($InfoDict['path.utf-8']['files'][0])) {
+                $this->PathKey = 'path.utf-8';
+            }
+            foreach ($InfoDict['files'] as $File) {
+                $TmpPath = [];
+                foreach ($File[$this->PathKey] as $SubPath) {
+                    $TmpPath[] = $SubPath;
+                }
+                $CurSize = (Int64::is_int($File['length'])
+                ? Int64::get($File['length'])
+                : $File['length']);
+                $this->Files[] = array($CurSize, implode('/', $TmpPath));
+                $this->Size += $CurSize;
+            }
+            uasort($this->Files, function ($a, $b) {
+                return strnatcasecmp($a[1], $b[1]);
+            });
         }
-        $CurSize = (Int64::is_int($File['length'])
-          ? Int64::get($File['length'])
-          : $File['length']);
-        $this->Files[] = array($CurSize, implode('/', $TmpPath));
-        $this->Size += $CurSize;
-      }
-      uasort($this->Files, function($a, $b) {
-          return strnatcasecmp($a[1], $b[1]);
-        });
+        return array($this->Size, $this->Files);
     }
-    return array($this->Size, $this->Files);
-  }
 
-  /**
-   * Find out the name of the torrent
-   *
-   * @return string torrent name
-   */
-  public function get_name() {
-    if (empty($this->Dec)) {
-      return false;
-    }
-    if (isset($this->Dec['info']['name.utf-8'])) {
-      return $this->Dec['info']['name.utf-8'];
+    /**
+     * Find out the name of the torrent
+     *
+     * @return string torrent name
+     */
+    public function get_name()
+    {
+        if (empty($this->Dec)) {
+            return false;
+        }
+        if (isset($this->Dec['info']['name.utf-8'])) {
+            return $this->Dec['info']['name.utf-8'];
+        }
+        return $this->Dec['info']['name'];
     }
-    return $this->Dec['info']['name'];
-  }
 
-  /**
-   * Find out the total size of the torrent
-   *
-   * @return string torrent size
-   */
-  public function get_size() {
-    if (empty($this->Files)) {
-      if (empty($this->Dec)) {
-        return false;
-      }
-      $FileList = $this->file_list();
+    /**
+     * Find out the total size of the torrent
+     *
+     * @return string torrent size
+     */
+    public function get_size()
+    {
+        if (empty($this->Files)) {
+            if (empty($this->Dec)) {
+                return false;
+            }
+            $FileList = $this->file_list();
+        }
+        return $FileList[0];
     }
-    return $FileList[0];
-  }
 
-  /**
-   * Checks if the "private" flag is present in the torrent
-   *
-   * @return true if the "private" flag is set
-   */
-  public function is_private() {
-    if (empty($this->Dec)) {
-      return false;
-    }
-    return isset($this->Dec['info']['private']) && Int64::get($this->Dec['info']['private']) == 1;
-  }
-  /**
-   * Add the "private" flag to the torrent
-   *
-   * @return true if a change was required
-   */
-  public function make_private() {
-    if (empty($this->Dec)) {
-      return false;
+    /**
+     * Checks if the "private" flag is present in the torrent
+     *
+     * @return true if the "private" flag is set
+     */
+    public function is_private()
+    {
+        if (empty($this->Dec)) {
+            return false;
+        }
+        return isset($this->Dec['info']['private']) && Int64::get($this->Dec['info']['private']) == 1;
     }
-    if ($this->is_private()) {
-      return false;
+    /**
+     * Add the "private" flag to the torrent
+     *
+     * @return true if a change was required
+     */
+    public function make_private()
+    {
+        if (empty($this->Dec)) {
+            return false;
+        }
+        if ($this->is_private()) {
+            return false;
+        }
+        $this->Dec['info']['private'] = Int64::make(1);
+        ksort($this->Dec['info']);
+        return true;
     }
-    $this->Dec['info']['private'] = Int64::make(1);
-    ksort($this->Dec['info']);
-    return true;
-  }
 
-  /**
-   * Add the "source" field to the torrent
-   *
-   * @return true if a change was required
-   */
-  public function make_sourced() {
-    $Sources = Users::get_upload_sources();
-    if (empty($this->Dec)) { return false; }
-    if (isset($this->Dec['info']['source']) && ($this->Dec['info']['source'] == $Sources[0] || $this->Dec['info']['source'] == $Sources[1])) {
-      return false;
+    /**
+     * Add the "source" field to the torrent
+     *
+     * @return true if a change was required
+     */
+    public function make_sourced()
+    {
+        $Sources = Users::get_upload_sources();
+        if (empty($this->Dec)) {
+            return false;
+        }
+        if (isset($this->Dec['info']['source']) && ($this->Dec['info']['source'] == $Sources[0] || $this->Dec['info']['source'] == $Sources[1])) {
+            return false;
+        }
+        $this->Dec['info']['source'] = $Sources[0];
+        ksort($this->Dec['info']);
+        return true;
     }
-    $this->Dec['info']['source'] = $Sources[0];
-    ksort($this->Dec['info']);
-    return true;
-  }
 
-  /**
-   * Calculate the torrent's info hash
-   *
-   * @return info hash in hexadecimal form
-   */
-  public function info_hash() {
-    if (empty($this->Dec) || !isset($this->Dec['info'])) {
-      return false;
+    /**
+     * Calculate the torrent's info hash
+     *
+     * @return info hash in hexadecimal form
+     */
+    public function info_hash()
+    {
+        if (empty($this->Dec) || !isset($this->Dec['info'])) {
+            return false;
+        }
+        return sha1($this->encode(false, 'info'));
     }
-    return sha1($this->encode(false, 'info'));
-  }
 
-  /**
-   * Add the announce URL to a torrent
-   */
-  public static function add_announce_url($Data, $Url) {
-    return 'd8:announce'.strlen($Url).':'.$Url.substr($Data, 1);
-  }
+    /**
+     * Add the announce URL to a torrent
+     */
+    public static function add_announce_url($Data, $Url)
+    {
+        return 'd8:announce'.strlen($Url).':'.$Url.substr($Data, 1);
+    }
 
-  /**
-   * Add list of announce URLs to a torrent
-   */
-  public static function add_announce_list($Data, $Urls) {
-    $r = 'd13:announce-listl';
-    for ($i = 0; $i < count($Urls); $i++) {
-      $r .= 'l';
-      for ($j = 0; $j < count($Urls[$i]); $j++) {
-        $r .= strlen($Urls[$i][$j]).':'.$Urls[$i][$j];
-      }
-      $r .= 'e';
+    /**
+     * Add list of announce URLs to a torrent
+     */
+    public static function add_announce_list($Data, $Urls)
+    {
+        $r = 'd13:announce-listl';
+        for ($i = 0; $i < count($Urls); $i++) {
+            $r .= 'l';
+            for ($j = 0; $j < count($Urls[$i]); $j++) {
+                $r .= strlen($Urls[$i][$j]).':'.$Urls[$i][$j];
+            }
+            $r .= 'e';
+        }
+        return $r.'e'.substr($Data, 1);
     }
-    return $r.'e'.substr($Data, 1);
-  }
 }

classes/bitcoinrpc.class.php

@@ -1,32 +1,32 @@
 <?php
-class BitcoinRpc {
+class BitcoinRpc
+{
+    public static function __callStatic($Method, $Args)
+    {
+        if (!defined('BITCOIN_RPC_URL')) {
+            return false;
+        }
+        $MessageID = mt_rand();
+        $Params = json_encode(array(
+        'method' => $Method,
+        'params' => $Args,
+        'id' => $MessageID));
 
-  public static function __callStatic($Method, $Args) {
-    if (!defined('BITCOIN_RPC_URL')) {
-      return false;
-    }
-    $MessageID = mt_rand();
-    $Params = json_encode(array(
-      'method' => $Method,
-      'params' => $Args,
-      'id' => $MessageID)
-    );
-
-    $Request = array(
-      'http' => array(
+        $Request = array(
+        'http' => array(
         'method' => 'POST',
         'header' => 'Content-type: application/json',
         'content' => $Params
         )
-      );
+        );
 
-    if (!$Response = file_get_contents(BITCOIN_RPC_URL, false, stream_context_create($Request))) {
-      return false;
-    }
-    $Response = json_decode($Response);
-    if ($Response->id != $MessageID || !empty($Response->error) || empty($Response->result)) {
-      return false;
+        if (!$Response = file_get_contents(BITCOIN_RPC_URL, false, stream_context_create($Request))) {
+            return false;
+        }
+        $Response = json_decode($Response);
+        if ($Response->id != $MessageID || !empty($Response->error) || empty($Response->result)) {
+            return false;
+        }
+        return $Response->result;
     }
-    return $Response->result;
-  }
 }

classes/bookmarks.class.php

@@ -1,5 +1,6 @@
-<?
-class Bookmarks {
+<?php
+class Bookmarks
+{
 
   /**
    * Check if can bookmark
@@ -7,93 +8,96 @@ class Bookmarks {
    * @param string $Type
    * @return boolean
    */
-  public static function can_bookmark($Type) {
-    return in_array($Type, array(
+    public static function can_bookmark($Type)
+    {
+        return in_array($Type, array(
         'torrent',
         'artist',
         'collage',
         'request'
-    ));
-  }
+        ));
+    }
 
-  /**
-   * Get the bookmark schema.
-   * Recommended usage:
-   * list($Table, $Col) = bookmark_schema('torrent');
-   *
-   * @param string $Type the type to get the schema for
-   */
-  public static function bookmark_schema($Type) {
-    switch ($Type) {
-      case 'torrent':
-        return array(
+    /**
+     * Get the bookmark schema.
+     * Recommended usage:
+     * list($Table, $Col) = bookmark_schema('torrent');
+     *
+     * @param string $Type the type to get the schema for
+     */
+    public static function bookmark_schema($Type)
+    {
+        switch ($Type) {
+            case 'torrent':
+                return array(
             'bookmarks_torrents',
             'GroupID'
-        );
-        break;
-      case 'artist':
-        return array(
+                );
+            break;
+            case 'artist':
+                return array(
             'bookmarks_artists',
             'ArtistID'
-        );
-        break;
-      case 'collage':
-        return array(
+                );
+            break;
+            case 'collage':
+                return array(
             'bookmarks_collages',
             'CollageID'
-        );
-        break;
-      case 'request':
-        return array(
+                );
+            break;
+            case 'request':
+                return array(
             'bookmarks_requests',
             'RequestID'
-        );
-        break;
-      default:
-        die('HAX');
+                );
+            break;
+            default:
+                die('HAX');
+        }
     }
-  }
 
-  /**
-   * Check if something is bookmarked
-   *
-   * @param string $Type
-   *          type of bookmarks to check
-   * @param int $ID
-   *          bookmark's id
-   * @return boolean
-   */
-  public static function has_bookmarked($Type, $ID) {
-    return in_array($ID, self::all_bookmarks($Type));
-  }
-
-  /**
-   * Fetch all bookmarks of a certain type for a user.
-   * If UserID is false than defaults to G::$LoggedUser['ID']
-   *
-   * @param string $Type
-   *          type of bookmarks to fetch
-   * @param int $UserID
-   *          userid whose bookmarks to get
-   * @return array the bookmarks
-   */
-  public static function all_bookmarks($Type, $UserID = false) {
-    if ($UserID === false) {
-      $UserID = G::$LoggedUser['ID'];
+    /**
+     * Check if something is bookmarked
+     *
+     * @param string $Type
+     *          type of bookmarks to check
+     * @param int $ID
+     *          bookmark's id
+     * @return boolean
+     */
+    public static function has_bookmarked($Type, $ID)
+    {
+        return in_array($ID, self::all_bookmarks($Type));
     }
-    $CacheKey = 'bookmarks_' . $Type . '_' . $UserID;
-    if (($Bookmarks = G::$Cache->get_value($CacheKey)) === false) {
-      list ($Table, $Col) = self::bookmark_schema($Type);
-      $QueryID = G::$DB->get_query_id();
-      G::$DB->query("
+
+    /**
+     * Fetch all bookmarks of a certain type for a user.
+     * If UserID is false than defaults to G::$LoggedUser['ID']
+     *
+     * @param string $Type
+     *          type of bookmarks to fetch
+     * @param int $UserID
+     *          userid whose bookmarks to get
+     * @return array the bookmarks
+     */
+    public static function all_bookmarks($Type, $UserID = false)
+    {
+        if ($UserID === false) {
+            $UserID = G::$LoggedUser['ID'];
+        }
+        $CacheKey = 'bookmarks_' . $Type . '_' . $UserID;
+        if (($Bookmarks = G::$Cache->get_value($CacheKey)) === false) {
+            list($Table, $Col) = self::bookmark_schema($Type);
+            $QueryID = G::$DB->get_query_id();
+            G::$DB->query("
         SELECT $Col
         FROM $Table
         WHERE UserID = '$UserID'");
-      $Bookmarks = G::$DB->collect($Col);
-      G::$DB->set_query_id($QueryID);
-      G::$Cache->cache_value($CacheKey, $Bookmarks, 0);
+            $Bookmarks = G::$DB->collect($Col);
+            G::$DB->set_query_id($QueryID);
+            G::$Cache->cache_value($CacheKey, $Bookmarks, 0);
+        }
+        return $Bookmarks;
     }
-    return $Bookmarks;
-  }
 }
-?>

classes/cache.class.php

@@ -1,4 +1,4 @@
-<?
+<?php
 /*************************************************************************|
 |--------------- Caching class -------------------------------------------|
 |*************************************************************************|
@@ -25,26 +25,31 @@ memcached -d -m 8192 -l 10.10.0.1 -t8 -C
 |*************************************************************************/
 
 if (!extension_loaded('memcache') && !extension_loaded('memcached')) {
-  die('Memcache Extension not loaded.');
+    die('Memcache Extension not loaded.');
 }
 
 if (class_exists('Memcached')) {
-  class MemcacheCompat extends Memcached {}
+    class MemcacheCompat extends Memcached
+    {
+    }
 } else {
-  class MemcacheCompat extends Memcache {}
+    class MemcacheCompat extends Memcache
+    {
+    }
 }
 
-class Cache extends MemcacheCompat {
-  // Torrent Group cache version
-  const GROUP_VERSION = 5;
-
-  public $CacheHits = [];
-  public $MemcacheDBArray = [];
-  public $MemcacheDBKey = '';
-  protected $InTransaction = false;
-  public $Time = 0;
-  private $Servers = [];
-  private $PersistentKeys = [
+class Cache extends MemcacheCompat
+{
+    // Torrent Group cache version
+    const GROUP_VERSION = 5;
+
+    public $CacheHits = [];
+    public $MemcacheDBArray = [];
+    public $MemcacheDBKey = '';
+    protected $InTransaction = false;
+    public $Time = 0;
+    private $Servers = [];
+    private $PersistentKeys = [
     'ajax_requests_*',
     'query_lock_*',
     'stats_*',
@@ -54,362 +59,392 @@ class Cache extends MemcacheCompat {
     // Cache-based features
     'global_notification',
     'notifications_one_reads_*',
-  ];
-  private $ClearedKeys = [];
-
-  public $CanClear = false;
-  public $InternalCache = true;
-
-  function __construct($Servers) {
-    if (is_subclass_of($this, 'Memcached')) parent::__construct();
-    $this->Servers = $Servers;
-    foreach ($Servers as $Server) {
-      if (is_subclass_of($this, 'Memcache')) {
-        $this->addServer($Server['host'], $Server['port'], true, $Server['buckets']);
-      } else {
-        $this->addServer(str_replace('unix://', '', $Server['host']), $Server['port'], $Server['buckets']);
-      }
-    }
-  }
-
-  //---------- Caching functions ----------//
-
-  // Allows us to set an expiration on otherwise perminantly cache'd values
-  // Useful for disabled users, locked threads, basically reducing ram usage
-  public function expire_value($Key, $Duration = 2592000) {
-    $StartTime = microtime(true);
-    $this->set($Key, $this->get($Key), $Duration);
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-  }
-
-  // Wrapper for Memcache::set, with the zlib option removed and default duration of 30 days
-  public function cache_value($Key, $Value, $Duration = 2592000) {
-    $StartTime = microtime(true);
-    if (empty($Key)) {
-      trigger_error("Cache insert failed for empty key");
-    }
-    $SetParams = [$Key, $Value, 0, $Duration];
-    if (is_subclass_of($this, 'Memcached')) unset($SetParams[2]);
-    if (!$this->set(...$SetParams)) {
-      trigger_error("Cache insert failed for key $Key");
+    ];
+    private $ClearedKeys = [];
+
+    public $CanClear = false;
+    public $InternalCache = true;
+
+    public function __construct($Servers)
+    {
+        if (is_subclass_of($this, 'Memcached')) {
+            parent::__construct();
+        }
+        $this->Servers = $Servers;
+        foreach ($Servers as $Server) {
+            if (is_subclass_of($this, 'Memcache')) {
+                $this->addServer($Server['host'], $Server['port'], true, $Server['buckets']);
+            } else {
+                $this->addServer(str_replace('unix://', '', $Server['host']), $Server['port'], $Server['buckets']);
+            }
+        }
     }
-    if ($this->InternalCache && array_key_exists($Key, $this->CacheHits)) {
-      $this->CacheHits[$Key] = $Value;
+
+    //---------- Caching functions ----------//
+
+    // Allows us to set an expiration on otherwise perminantly cache'd values
+    // Useful for disabled users, locked threads, basically reducing ram usage
+    public function expire_value($Key, $Duration = 2592000)
+    {
+        $StartTime = microtime(true);
+        $this->set($Key, $this->get($Key), $Duration);
+        $this->Time += (microtime(true) - $StartTime) * 1000;
     }
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-  }
-
-  // Wrapper for Memcache::add, with the zlib option removed and default duration of 30 days
-  public function add_value($Key, $Value, $Duration = 2592000) {
-    $StartTime = microtime(true);
-    $AddParams = [$Key, $Value, false, $Duration];
-    if (is_subclass_of($this, 'Memcached')) unset($AddParams[2]);
-    $Added = $this->add(...$AddParams);
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-    return $Added;
-  }
-
-  public function replace_value($Key, $Value, $Duration = 2592000) {
-    $StartTime = microtime(true);
-    $ReplaceParams = [$Key, $Value, false, $Duration];
-    if (is_subclass_of($this, 'Memcached')) unset($ReplaceParams[2]);
-    $this->replace(...$ReplaceParams);
-    if ($this->InternalCache && array_key_exists($Key, $this->CacheHits)) {
-      $this->CacheHits[$Key] = $Value;
+
+    // Wrapper for Memcache::set, with the zlib option removed and default duration of 30 days
+    public function cache_value($Key, $Value, $Duration = 2592000)
+    {
+        $StartTime = microtime(true);
+        if (empty($Key)) {
+            trigger_error("Cache insert failed for empty key");
+        }
+        $SetParams = [$Key, $Value, 0, $Duration];
+        if (is_subclass_of($this, 'Memcached')) {
+            unset($SetParams[2]);
+        }
+        if (!$this->set(...$SetParams)) {
+            trigger_error("Cache insert failed for key $Key");
+        }
+        if ($this->InternalCache && array_key_exists($Key, $this->CacheHits)) {
+            $this->CacheHits[$Key] = $Value;
+        }
+        $this->Time += (microtime(true) - $StartTime) * 1000;
     }
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-  }
 
-  public function get_value($Key, $NoCache = false) {
-    if (!$this->InternalCache) {
-      $NoCache = true;
+    // Wrapper for Memcache::add, with the zlib option removed and default duration of 30 days
+    public function add_value($Key, $Value, $Duration = 2592000)
+    {
+        $StartTime = microtime(true);
+        $AddParams = [$Key, $Value, false, $Duration];
+        if (is_subclass_of($this, 'Memcached')) {
+            unset($AddParams[2]);
+        }
+        $Added = $this->add(...$AddParams);
+        $this->Time += (microtime(true) - $StartTime) * 1000;
+        return $Added;
     }
-    $StartTime = microtime(true);
-    if (empty($Key)) {
-      trigger_error('Cache retrieval failed for empty key');
+
+    public function replace_value($Key, $Value, $Duration = 2592000)
+    {
+        $StartTime = microtime(true);
+        $ReplaceParams = [$Key, $Value, false, $Duration];
+        if (is_subclass_of($this, 'Memcached')) {
+            unset($ReplaceParams[2]);
+        }
+        $this->replace(...$ReplaceParams);
+        if ($this->InternalCache && array_key_exists($Key, $this->CacheHits)) {
+            $this->CacheHits[$Key] = $Value;
+        }
+        $this->Time += (microtime(true) - $StartTime) * 1000;
     }
 
-    if (!empty($_GET['clearcache']) && $this->CanClear && !isset($this->ClearedKeys[$Key]) && !Misc::in_array_partial($Key, $this->PersistentKeys)) {
-      if ($_GET['clearcache'] === '1') {
-        // Because check_perms() isn't true until LoggedUser is pulled from the cache, we have to remove the entries loaded before the LoggedUser data
-        // Because of this, not user cache data will require a secondary pageload following the clearcache to update
-        if (count($this->CacheHits) > 0) {
-          foreach (array_keys($this->CacheHits) as $HitKey) {
-            if (!isset($this->ClearedKeys[$HitKey]) && !Misc::in_array_partial($HitKey, $this->PersistentKeys)) {
-              $this->delete($HitKey);
-              unset($this->CacheHits[$HitKey]);
-              $this->ClearedKeys[$HitKey] = true;
+    public function get_value($Key, $NoCache = false)
+    {
+        if (!$this->InternalCache) {
+            $NoCache = true;
+        }
+        $StartTime = microtime(true);
+        if (empty($Key)) {
+            trigger_error('Cache retrieval failed for empty key');
+        }
+
+        if (!empty($_GET['clearcache']) && $this->CanClear && !isset($this->ClearedKeys[$Key]) && !Misc::in_array_partial($Key, $this->PersistentKeys)) {
+            if ($_GET['clearcache'] === '1') {
+                // Because check_perms() isn't true until LoggedUser is pulled from the cache, we have to remove the entries loaded before the LoggedUser data
+                // Because of this, not user cache data will require a secondary pageload following the clearcache to update
+                if (count($this->CacheHits) > 0) {
+                    foreach (array_keys($this->CacheHits) as $HitKey) {
+                        if (!isset($this->ClearedKeys[$HitKey]) && !Misc::in_array_partial($HitKey, $this->PersistentKeys)) {
+                            $this->delete($HitKey);
+                            unset($this->CacheHits[$HitKey]);
+                            $this->ClearedKeys[$HitKey] = true;
+                        }
+                    }
+                }
+                $this->delete($Key);
+                $this->Time += (microtime(true) - $StartTime) * 1000;
+                return false;
+            } elseif ($_GET['clearcache'] == $Key) {
+                $this->delete($Key);
+                $this->Time += (microtime(true) - $StartTime) * 1000;
+                return false;
+            } elseif (substr($_GET['clearcache'], -1) === '*') {
+                $Prefix = substr($_GET['clearcache'], 0, -1);
+                if ($Prefix === '' || $Prefix === substr($Key, 0, strlen($Prefix))) {
+                    $this->delete($Key);
+                    $this->Time += (microtime(true) - $StartTime) * 1000;
+                    return false;
+                }
             }
-          }
+            $this->ClearedKeys[$Key] = true;
+        }
+
+        // For cases like the forums, if a key is already loaded, grab the existing pointer
+        if (isset($this->CacheHits[$Key]) && !$NoCache) {
+            $this->Time += (microtime(true) - $StartTime) * 1000;
+            return $this->CacheHits[$Key];
+        }
+
+        $Return = $this->get($Key);
+        if ($Return !== false) {
+            $this->CacheHits[$Key] = $NoCache ? null : $Return;
         }
-        $this->delete($Key);
-        $this->Time += (microtime(true) - $StartTime) * 1000;
-        return false;
-      } elseif ($_GET['clearcache'] == $Key) {
-        $this->delete($Key);
         $this->Time += (microtime(true) - $StartTime) * 1000;
-        return false;
-      } elseif (substr($_GET['clearcache'], -1) === '*') {
-        $Prefix = substr($_GET['clearcache'], 0, -1);
-        if ($Prefix === '' || $Prefix === substr($Key, 0, strlen($Prefix))) {
-          $this->delete($Key);
-          $this->Time += (microtime(true) - $StartTime) * 1000;
-          return false;
-        }
-      }
-      $this->ClearedKeys[$Key] = true;
+        return $Return;
     }
 
-    // For cases like the forums, if a key is already loaded, grab the existing pointer
-    if (isset($this->CacheHits[$Key]) && !$NoCache) {
-      $this->Time += (microtime(true) - $StartTime) * 1000;
-      return $this->CacheHits[$Key];
+    // Wrapper for Memcache::delete. For a reason, see above.
+    public function delete_value($Key)
+    {
+        $StartTime = microtime(true);
+        if (empty($Key)) {
+            trigger_error('Cache deletion failed for empty key');
+        }
+        if (!$this->delete($Key)) {
+            //trigger_error("Cache delete failed for key $Key");
+        }
+        unset($this->CacheHits[$Key]);
+        $this->Time += (microtime(true) - $StartTime) * 1000;
     }
 
-    $Return = $this->get($Key);
-    if ($Return !== false) {
-      $this->CacheHits[$Key] = $NoCache ? null : $Return;
-    }
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-    return $Return;
-  }
-
-  // Wrapper for Memcache::delete. For a reason, see above.
-  public function delete_value($Key) {
-    $StartTime = microtime(true);
-    if (empty($Key)) {
-      trigger_error('Cache deletion failed for empty key');
-    }
-    if (!$this->delete($Key)) {
-      //trigger_error("Cache delete failed for key $Key");
-    }
-    unset($this->CacheHits[$Key]);
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-  }
-
-  public function increment_value($Key, $Value = 1) {
-    $StartTime = microtime(true);
-    $NewVal = $this->increment($Key, $Value);
-    if (isset($this->CacheHits[$Key])) {
-      $this->CacheHits[$Key] = $NewVal;
-    }
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-  }
-
-  public function decrement_value($Key, $Value = 1) {
-    $StartTime = microtime(true);
-    $NewVal = $this->decrement($Key, $Value);
-    if (isset($this->CacheHits[$Key])) {
-      $this->CacheHits[$Key] = $NewVal;
-    }
-    $this->Time += (microtime(true) - $StartTime) * 1000;
-  }
-
-  //---------- memcachedb functions ----------//
-
-  public function begin_transaction($Key) {
-    $Value = $this->get($Key);
-    if (!is_array($Value)) {
-      $this->InTransaction = false;
-      $this->MemcacheDBKey = [];
-      $this->MemcacheDBKey = '';
-      return false;
-    }
-    $this->MemcacheDBArray = $Value;
-    $this->MemcacheDBKey = $Key;
-    $this->InTransaction = true;
-    return true;
-  }
-
-  public function cancel_transaction() {
-    $this->InTransaction = false;
-    $this->MemcacheDBKey = [];
-    $this->MemcacheDBKey = '';
-  }
-
-  public function commit_transaction($Time = 2592000) {
-    if (!$this->InTransaction) {
-      return false;
-    }
-    $this->cache_value($this->MemcacheDBKey, $this->MemcacheDBArray, $Time);
-    $this->InTransaction = false;
-  }
-
-  // Updates multiple rows in an array
-  public function update_transaction($Rows, $Values) {
-    if (!$this->InTransaction) {
-      return false;
-    }
-    $Array = $this->MemcacheDBArray;
-    if (is_array($Rows)) {
-      $i = 0;
-      $Keys = $Rows[0];
-      $Property = $Rows[1];
-      foreach ($Keys as $Row) {
-        $Array[$Row][$Property] = $Values[$i];
-        $i++;
-      }
-    } else {
-      $Array[$Rows] = $Values;
-    }
-    $this->MemcacheDBArray = $Array;
-  }
-
-  // Updates multiple values in a single row in an array
-  // $Values must be an associative array with key:value pairs like in the array we're updating
-  public function update_row($Row, $Values) {
-    if (!$this->InTransaction) {
-      return false;
-    }
-    if ($Row === false) {
-      $UpdateArray = $this->MemcacheDBArray;
-    } else {
-      $UpdateArray = $this->MemcacheDBArray[$Row];
-    }
-    foreach ($Values as $Key => $Value) {
-      if (!array_key_exists($Key, $UpdateArray)) {
-        trigger_error('Bad transaction key ('.$Key.') for cache '.$this->MemcacheDBKey);
-      }
-      if ($Value === '+1') {
-        if (!is_number($UpdateArray[$Key])) {
-          trigger_error('Tried to increment non-number ('.$Key.') for cache '.$this->MemcacheDBKey);
-        }
-        ++$UpdateArray[$Key]; // Increment value
-      } elseif ($Value === '-1') {
-        if (!is_number($UpdateArray[$Key])) {
-          trigger_error('Tried to decrement non-number ('.$Key.') for cache '.$this->MemcacheDBKey);
-        }
-        --$UpdateArray[$Key]; // Decrement value
-      } else {
-        $UpdateArray[$Key] = $Value; // Otherwise, just alter value
-      }
-    }
-    if ($Row === false) {
-      $this->MemcacheDBArray = $UpdateArray;
-    } else {
-      $this->MemcacheDBArray[$Row] = $UpdateArray;
+    public function increment_value($Key, $Value = 1)
+    {
+        $StartTime = microtime(true);
+        $NewVal = $this->increment($Key, $Value);
+        if (isset($this->CacheHits[$Key])) {
+            $this->CacheHits[$Key] = $NewVal;
+        }
+        $this->Time += (microtime(true) - $StartTime) * 1000;
     }
-  }
 
-  // Increments multiple values in a single row in an array
-  // $Values must be an associative array with key:value pairs like in the array we're updating
-  public function increment_row($Row, $Values) {
-    if (!$this->InTransaction) {
-      return false;
-    }
-    if ($Row === false) {
-      $UpdateArray = $this->MemcacheDBArray;
-    } else {
-      $UpdateArray = $this->MemcacheDBArray[$Row];
-    }
-    foreach ($Values as $Key => $Value) {
-      if (!array_key_exists($Key, $UpdateArray)) {
-        trigger_error("Bad transaction key ($Key) for cache ".$this->MemcacheDBKey);
-      }
-      if (!is_number($Value)) {
-        trigger_error("Tried to increment with non-number ($Key) for cache ".$this->MemcacheDBKey);
-      }
-      $UpdateArray[$Key] += $Value; // Increment value
-    }
-    if ($Row === false) {
-      $this->MemcacheDBArray = $UpdateArray;
-    } else {
-      $this->MemcacheDBArray[$Row] = $UpdateArray;
+    public function decrement_value($Key, $Value = 1)
+    {
+        $StartTime = microtime(true);
+        $NewVal = $this->decrement($Key, $Value);
+        if (isset($this->CacheHits[$Key])) {
+            $this->CacheHits[$Key] = $NewVal;
+        }
+        $this->Time += (microtime(true) - $StartTime) * 1000;
     }
-  }
 
-  // Insert a value at the beginning of the array
-  public function insert_front($Key, $Value) {
-    if (!$this->InTransaction) {
-      return false;
+    //---------- memcachedb functions ----------//
+
+    public function begin_transaction($Key)
+    {
+        $Value = $this->get($Key);
+        if (!is_array($Value)) {
+            $this->InTransaction = false;
+            $this->MemcacheDBKey = [];
+            $this->MemcacheDBKey = '';
+            return false;
+        }
+        $this->MemcacheDBArray = $Value;
+        $this->MemcacheDBKey = $Key;
+        $this->InTransaction = true;
+        return true;
     }
-    if ($Key === '') {
-      array_unshift($this->MemcacheDBArray, $Value);
-    } else {
-      $this->MemcacheDBArray = array($Key=>$Value) + $this->MemcacheDBArray;
+
+    public function cancel_transaction()
+    {
+        $this->InTransaction = false;
+        $this->MemcacheDBKey = [];
+        $this->MemcacheDBKey = '';
     }
-  }
 
-  // Insert a value at the end of the array
-  public function insert_back($Key, $Value) {
-    if (!$this->InTransaction) {
-      return false;
+    public function commit_transaction($Time = 2592000)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        $this->cache_value($this->MemcacheDBKey, $this->MemcacheDBArray, $Time);
+        $this->InTransaction = false;
     }
-    if ($Key === '') {
-      array_push($this->MemcacheDBArray, $Value);
-    } else {
-      $this->MemcacheDBArray = $this->MemcacheDBArray + array($Key=>$Value);
+
+    // Updates multiple rows in an array
+    public function update_transaction($Rows, $Values)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        $Array = $this->MemcacheDBArray;
+        if (is_array($Rows)) {
+            $i = 0;
+            $Keys = $Rows[0];
+            $Property = $Rows[1];
+            foreach ($Keys as $Row) {
+                $Array[$Row][$Property] = $Values[$i];
+                $i++;
+            }
+        } else {
+            $Array[$Rows] = $Values;
+        }
+        $this->MemcacheDBArray = $Array;
     }
 
-  }
+    // Updates multiple values in a single row in an array
+    // $Values must be an associative array with key:value pairs like in the array we're updating
+    public function update_row($Row, $Values)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        if ($Row === false) {
+            $UpdateArray = $this->MemcacheDBArray;
+        } else {
+            $UpdateArray = $this->MemcacheDBArray[$Row];
+        }
+        foreach ($Values as $Key => $Value) {
+            if (!array_key_exists($Key, $UpdateArray)) {
+                trigger_error('Bad transaction key ('.$Key.') for cache '.$this->MemcacheDBKey);
+            }
+            if ($Value === '+1') {
+                if (!is_number($UpdateArray[$Key])) {
+                    trigger_error('Tried to increment non-number ('.$Key.') for cache '.$this->MemcacheDBKey);
+                }
+                ++$UpdateArray[$Key]; // Increment value
+            } elseif ($Value === '-1') {
+                if (!is_number($UpdateArray[$Key])) {
+                    trigger_error('Tried to decrement non-number ('.$Key.') for cache '.$this->MemcacheDBKey);
+                }
+                --$UpdateArray[$Key]; // Decrement value
+            } else {
+                $UpdateArray[$Key] = $Value; // Otherwise, just alter value
+            }
+        }
+        if ($Row === false) {
+            $this->MemcacheDBArray = $UpdateArray;
+        } else {
+            $this->MemcacheDBArray[$Row] = $UpdateArray;
+        }
+    }
 
-  public function insert($Key, $Value) {
-    if (!$this->InTransaction) {
-      return false;
+    // Increments multiple values in a single row in an array
+    // $Values must be an associative array with key:value pairs like in the array we're updating
+    public function increment_row($Row, $Values)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        if ($Row === false) {
+            $UpdateArray = $this->MemcacheDBArray;
+        } else {
+            $UpdateArray = $this->MemcacheDBArray[$Row];
+        }
+        foreach ($Values as $Key => $Value) {
+            if (!array_key_exists($Key, $UpdateArray)) {
+                trigger_error("Bad transaction key ($Key) for cache ".$this->MemcacheDBKey);
+            }
+            if (!is_number($Value)) {
+                trigger_error("Tried to increment with non-number ($Key) for cache ".$this->MemcacheDBKey);
+            }
+            $UpdateArray[$Key] += $Value; // Increment value
+        }
+        if ($Row === false) {
+            $this->MemcacheDBArray = $UpdateArray;
+        } else {
+            $this->MemcacheDBArray[$Row] = $UpdateArray;
+        }
     }
-    if ($Key === '') {
-      $this->MemcacheDBArray[] = $Value;
-    } else {
-      $this->MemcacheDBArray[$Key] = $Value;
+
+    // Insert a value at the beginning of the array
+    public function insert_front($Key, $Value)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        if ($Key === '') {
+            array_unshift($this->MemcacheDBArray, $Value);
+        } else {
+            $this->MemcacheDBArray = array($Key=>$Value) + $this->MemcacheDBArray;
+        }
     }
-  }
 
-  public function delete_row($Row) {
-    if (!$this->InTransaction) {
-      return false;
+    // Insert a value at the end of the array
+    public function insert_back($Key, $Value)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        if ($Key === '') {
+            array_push($this->MemcacheDBArray, $Value);
+        } else {
+            $this->MemcacheDBArray = $this->MemcacheDBArray + array($Key=>$Value);
+        }
     }
-    if (!isset($this->MemcacheDBArray[$Row])) {
-      trigger_error("Tried to delete non-existent row ($Row) for cache ".$this->MemcacheDBKey);
+
+    public function insert($Key, $Value)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        if ($Key === '') {
+            $this->MemcacheDBArray[] = $Value;
+        } else {
+            $this->MemcacheDBArray[$Key] = $Value;
+        }
     }
-    unset($this->MemcacheDBArray[$Row]);
-  }
-
-  public function update($Key, $Rows, $Values, $Time = 2592000) {
-    if (!$this->InTransaction) {
-      $this->begin_transaction($Key);
-      $this->update_transaction($Rows, $Values);
-      $this->commit_transaction($Time);
-    } else {
-      $this->update_transaction($Rows, $Values);
+
+    public function delete_row($Row)
+    {
+        if (!$this->InTransaction) {
+            return false;
+        }
+        if (!isset($this->MemcacheDBArray[$Row])) {
+            trigger_error("Tried to delete non-existent row ($Row) for cache ".$this->MemcacheDBKey);
+        }
+        unset($this->MemcacheDBArray[$Row]);
     }
-  }
-
-  /**
-   * Tries to set a lock. Expiry time is one hour to avoid indefinite locks
-   *
-   * @param string $LockName name on the lock
-   * @return true if lock was acquired
-   */
-  public function get_query_lock($LockName) {
-    return $this->add_value('query_lock_'.$LockName, 1, 3600);
-  }
-
-  /**
-   * Remove lock
-   *
-   * @param string $LockName name on the lock
-   */
-  public function clear_query_lock($LockName) {
-    $this->delete_value('query_lock_'.$LockName);
-  }
-
-  /**
-   * Get cache server status
-   *
-   * @return array (host => int status, ...)
-   */
-  public function server_status() {
-    $Status = [];
-    if (is_subclass_of($this, 'Memcached')) {
-      $MemcachedStats = $this->getStats();
+
+    public function update($Key, $Rows, $Values, $Time = 2592000)
+    {
+        if (!$this->InTransaction) {
+            $this->begin_transaction($Key);
+            $this->update_transaction($Rows, $Values);
+            $this->commit_transaction($Time);
+        } else {
+            $this->update_transaction($Rows, $Values);
+        }
     }
-    foreach ($this->Servers as $Server) {
-      if (is_subclass_of($this, 'Memcached')) {
-        $Status["$Server[host]:$Server[port]"] = gettype($MemcachedStats["$Server[host]:$Server[port]"]) == 'array' ? 1 : 0;
-      } else {
-        $Status["$Server[host]:$Server[port]"] = $this->getServerStatus($Server['host'], $Server['port']);
-      }
+
+    /**
+     * Tries to set a lock. Expiry time is one hour to avoid indefinite locks
+     *
+     * @param string $LockName name on the lock
+     * @return true if lock was acquired
+     */
+    public function get_query_lock($LockName)
+    {
+        return $this->add_value('query_lock_'.$LockName, 1, 3600);
+    }
+
+    /**
+     * Remove lock
+     *
+     * @param string $LockName name on the lock
+     */
+    public function clear_query_lock($LockName)
+    {
+        $this->delete_value('query_lock_'.$LockName);
+    }
+
+    /**
+     * Get cache server status
+     *
+     * @return array (host => int status, ...)
+     */
+    public function server_status()
+    {
+        $Status = [];
+        if (is_subclass_of($this, 'Memcached')) {
+            $MemcachedStats = $this->getStats();
+        }
+        foreach ($this->Servers as $Server) {
+            if (is_subclass_of($this, 'Memcached')) {
+                $Status["$Server[host]:$Server[port]"] = gettype($MemcachedStats["$Server[host]:$Server[port]"]) == 'array' ? 1 : 0;
+            } else {
+                $Status["$Server[host]:$Server[port]"] = $this->getServerStatus($Server['host'], $Server['port']);
+            }
+        }
+        return $Status;
     }
-    return $Status;
-  }
 }