/**
  * Creates an ImportXMLReader drawing from the source provided
  * @param ImportSource $source
  * @param Config $config
  */
 function __construct(ImportSource $source, Config $config = null)
 {
     $this->reader = new XMLReader();
     if (!$config) {
         wfDeprecated(__METHOD__ . ' without a Config instance', '1.25');
         $config = ConfigFactory::getDefaultInstance()->makeConfig('main');
     }
     $this->config = $config;
     if (!in_array('uploadsource', stream_get_wrappers())) {
         stream_wrapper_register('uploadsource', 'UploadSourceAdapter');
     }
     $id = UploadSourceAdapter::registerSource($source);
     if (defined('LIBXML_PARSEHUGE')) {
         $this->reader->open("uploadsource://{$id}", null, LIBXML_PARSEHUGE);
     } else {
         $this->reader->open("uploadsource://{$id}");
     }
     // Default callbacks
     $this->setPageCallback(array($this, 'beforeImportPage'));
     $this->setRevisionCallback(array($this, "importRevision"));
     $this->setUploadCallback(array($this, 'importUpload'));
     $this->setLogItemCallback(array($this, 'importLogItem'));
     $this->setPageOutCallback(array($this, 'finishImportPage'));
     $this->importTitleFactory = new NaiveImportTitleFactory();
 }

 /**
  * @param &$reader LogReader: where to get our data from
  * @param $flags Integer: Bitwise combination of flags:
  *     LogEventsList::NO_ACTION_LINK   Don't show restore/unblock/block links
  *
  * @deprecated since 1.14
  */
 function __construct(&$reader, $flags = 0)
 {
     wfDeprecated(__METHOD__);
     $this->reader =& $reader;
     $this->reader->pager->mLogEventsList->flags = $flags;
     # Aliases for shorter code...
     $this->pager =& $this->reader->pager;
     $this->list =& $this->reader->pager->mLogEventsList;
 }

 /**
  * @param string|null $prefix
  * @since 1.26 The prefix argument should be omitted, as the strip marker
  *  prefix string is now a constant.
  */
 public function __construct($prefix = null)
 {
     if ($prefix !== null) {
         wfDeprecated(__METHOD__ . ' with called with $prefix argument' . ' (call with no arguments instead)', '1.26');
     }
     $this->data = ['nowiki' => [], 'general' => []];
     $this->regex = '/' . Parser::MARKER_PREFIX . "([^<>&'\"]+)" . Parser::MARKER_SUFFIX . '/';
     $this->circularRefGuard = [];
 }

 /**
  * Returns the LBFactory class to use and the load balancer configuration.
  *
  * @param array $config (e.g. $wgLBFactoryConf)
  * @return string Class name
  */
 public static function getLBFactoryClass(array $config)
 {
     // For configuration backward compatibility after removing
     // underscores from class names in MediaWiki 1.23.
     $bcClasses = array('LBFactory_Simple' => 'LBFactorySimple', 'LBFactory_Single' => 'LBFactorySingle', 'LBFactory_Multi' => 'LBFactoryMulti', 'LBFactory_Fake' => 'LBFactoryFake');
     $class = $config['class'];
     if (isset($bcClasses[$class])) {
         $class = $bcClasses[$class];
         wfDeprecated('$wgLBFactoryConf must be updated. See RELEASE-NOTES for details', '1.23');
     }
     return $class;
 }

 /**
  * Return the URL of an image, provided its name.
  *
  * Backwards-compatibility for extensions.
  * Note that fromSharedDirectory will only use the shared path for files
  * that actually exist there now, and will return local paths otherwise.
  *
  * @param string $name	Name of the image, without the leading "Image:"
  * @param boolean $fromSharedDirectory	Should this be in $wgSharedUploadPath?
  * @return string URL of $name image
  * @deprecated
  */
 static function imageUrl($name, $fromSharedDirectory = false)
 {
     wfDeprecated(__METHOD__);
     $image = null;
     if ($fromSharedDirectory) {
         $image = wfFindFile($name);
     }
     if (!$image) {
         $image = wfLocalFile($name);
     }
     return $image->getUrl();
 }

	/**
	 * Set page title and show header for this log type
	 * @param $type Array
	 * @deprecated in 1.19
	 */
	public function showHeader( $type ) {
		wfDeprecated( __METHOD__, '1.19' );
		// If only one log type is used, then show a special message...
		$headerType = count( $type ) == 1 ? $type[0] : '';
		$out = $this->getOutput();
		if ( LogPage::isLogType( $headerType ) ) {
			$page = new LogPage( $headerType );
			$out->setPageTitle( $page->getName()->text() );
			$out->addHTML( $page->getDescription()->parseAsBlock() );
		} else {
			$out->addHTML( $this->msg( 'alllogstext' )->parse() );
		}
	}

 /**
  * @param string $address String with an email address, or a User object
  * @param string $name Human-readable name if a string address is given
  * @param string $realName Human-readable real name if a string address is given
  */
 function __construct($address, $name = null, $realName = null)
 {
     if (is_object($address) && $address instanceof User) {
         // Old calling format, now deprecated
         wfDeprecated(__METHOD__ . ' with a User object', '1.24');
         $this->address = $address->getEmail();
         $this->name = $address->getName();
         $this->realName = $address->getRealName();
     } else {
         $this->address = strval($address);
         $this->name = strval($name);
         $this->realName = strval($realName);
     }
 }

 /**
  * Make a string to go after an SQL LIKE, which will match the specified
  * string. There are several kinds of filter entry:
  *     *.domain.com    -  Produces http://com.domain.%, matches domain.com
  *                        and www.domain.com
  *     domain.com      -  Produces http://com.domain./%, matches domain.com
  *                        or domain.com/ but not www.domain.com
  *     *.domain.com/x  -  Produces http://com.domain.%/x%, matches
  *                        www.domain.com/xy
  *     domain.com/x    -  Produces http://com.domain./x%, matches
  *                        domain.com/xy but not www.domain.com/xy
  *
  * Asterisks in any other location are considered invalid.
  * 
  * @param $filterEntry String: domainparts
  * @param $prot        String: protocol
  * @return String
  * @deprecated Use makeLikeArray() and pass result to Database::buildLike() instead
  */
 public static function makeLike($filterEntry, $prot = 'http://')
 {
     wfDeprecated(__METHOD__);
     $like = self::makeLikeArray($filterEntry, $prot);
     if (!$like) {
         return false;
     }
     $dbw = wfGetDB(DB_MASTER);
     $s = $dbw->buildLike($like);
     $m = false;
     if (preg_match("/^ *LIKE '(.*)' *\$/", $s, $m)) {
         return $m[1];
     } else {
         throw new MWException(__METHOD__ . ': this DBMS is not supported by this function.');
     }
 }

 function _newObject()
 {
     /* Put the caller offset for wfDeprecated as 6, as
      * that gives the function that uses this object, since:
      * 1 = this function ( _newObject )
      * 2 = StubObject::_unstub
      * 3 = StubObject::_call
      * 4 = StubObject::__call
      * 5 = DeprecatedGlobal::<method of global called>
      * 6 = Actual function using the global.
      * Of course its theoretically possible to have other call
      * sequences for this method, but that seems to be
      * rather unlikely.
      */
     wfDeprecated('$' . $this->mGlobal, $this->mVersion, false, 6);
     return $this->mRealValue;
 }

/**
 * Returns the browser/OS data from the request header
 * Note: headers are spoofable
 *
 * @deprecated in 1.18; use $wgRequest->getHeader( 'User-Agent' ) instead.
 * @return string
 */
function wfGetAgent()
{
    wfDeprecated(__FUNCTION__);
    if (function_exists('apache_request_headers')) {
        // More reliable than $_SERVER due to case and -/_ folding
        $set = array();
        foreach (apache_request_headers() as $tempName => $tempValue) {
            $set[strtoupper($tempName)] = $tempValue;
        }
        $index = strtoupper('User-Agent');
    } else {
        // Subject to spoofing with headers like X_Forwarded_For
        $set = $_SERVER;
        $index = 'HTTP_USER_AGENT';
    }
    if (isset($set[$index])) {
        return $set[$index];
    } else {
        return '';
    }
}

 function __construct($p = null)
 {
     global $wgSharedDB, $wgSQLiteDataDir;
     if (!is_array($p)) {
         // legacy calling pattern
         wfDeprecated(__METHOD__ . " method called without parameter array.", "1.22");
         $args = func_get_args();
         $p = array('host' => isset($args[0]) ? $args[0] : false, 'user' => isset($args[1]) ? $args[1] : false, 'password' => isset($args[2]) ? $args[2] : false, 'dbname' => isset($args[3]) ? $args[3] : false, 'flags' => isset($args[4]) ? $args[4] : 0, 'tablePrefix' => isset($args[5]) ? $args[5] : 'get from global', 'schema' => 'get from global', 'foreign' => isset($args[6]) ? $args[6] : false);
     }
     $this->mDBname = $p['dbname'];
     parent::__construct($p);
     // parent doesn't open when $user is false, but we can work with $dbName
     if ($p['dbname'] && !$this->isOpen()) {
         if ($this->open($p['host'], $p['user'], $p['password'], $p['dbname'])) {
             if ($wgSharedDB) {
                 $this->attachDatabase($wgSharedDB);
             }
         }
     }
     $this->lockMgr = new FSLockManager(array('lockDirectory' => "{$wgSQLiteDataDir}/locks"));
 }

 /**
  * Creates an ImportXMLReader drawing from the source provided
  * @param ImportSource $source
  * @param Config $config
  * @throws Exception
  */
 function __construct(ImportSource $source, Config $config = null)
 {
     if (!class_exists('XMLReader')) {
         throw new Exception('Import requires PHP to have been compiled with libxml support');
     }
     $this->reader = new XMLReader();
     if (!$config) {
         wfDeprecated(__METHOD__ . ' without a Config instance', '1.25');
         $config = ConfigFactory::getDefaultInstance()->makeConfig('main');
     }
     $this->config = $config;
     if (!in_array('uploadsource', stream_get_wrappers())) {
         stream_wrapper_register('uploadsource', 'UploadSourceAdapter');
     }
     $id = UploadSourceAdapter::registerSource($source);
     // Enable the entity loader, as it is needed for loading external URLs via
     // XMLReader::open (T86036)
     $oldDisable = libxml_disable_entity_loader(false);
     if (defined('LIBXML_PARSEHUGE')) {
         $status = $this->reader->open("uploadsource://{$id}", null, LIBXML_PARSEHUGE);
     } else {
         $status = $this->reader->open("uploadsource://{$id}");
     }
     if (!$status) {
         $error = libxml_get_last_error();
         libxml_disable_entity_loader($oldDisable);
         throw new MWException('Encountered an internal error while initializing WikiImporter object: ' . $error->message);
     }
     libxml_disable_entity_loader($oldDisable);
     // Default callbacks
     $this->setPageCallback(array($this, 'beforeImportPage'));
     $this->setRevisionCallback(array($this, "importRevision"));
     $this->setUploadCallback(array($this, 'importUpload'));
     $this->setLogItemCallback(array($this, 'importLogItem'));
     $this->setPageOutCallback(array($this, 'finishImportPage'));
     $this->importTitleFactory = new NaiveImportTitleFactory();
 }

 /**
  * Move this page without authentication
  *
  * @deprecated since 1.25 use MovePage class instead
  * @param Title $nt The new page Title
  * @return array|bool True on success, getUserPermissionsErrors()-like array on failure
  */
 public function moveNoAuth(&$nt)
 {
     wfDeprecated(__METHOD__, '1.25');
     return $this->moveTo($nt, false);
 }

 /**
  * Fetch an appropriate changes list class for the main context
  * This first argument used to be an User object.
  *
  * @deprecated in 1.18; use newFromContext() instead
  * @param $unused Unused
  * @return ChangesList|EnhancedChangesList|OldChangesList derivative
  */
 public static function newFromUser($unused)
 {
     wfDeprecated(__METHOD__, '1.18');
     return self::newFromContext(RequestContext::getMain());
 }

 /**
  * $magicarr is an associative array of (magic word ID => replacement)
  * This method uses the php feature to do several replacements at the same time,
  * thereby gaining some efficiency. The result is placed in the out variable
  * $result. The return value is true if something was replaced.
  * @deprecated since 1.25, unused
  *
  * @param array $magicarr
  * @param string $subject
  * @param string $result
  *
  * @return bool
  */
 function replaceMultiple($magicarr, $subject, &$result)
 {
     wfDeprecated(__METHOD__, '1.25');
     $search = array();
     $replace = array();
     foreach ($magicarr as $id => $replacement) {
         $mw = MagicWord::get($id);
         $search[] = $mw->getRegex();
         $replace[] = $replacement;
     }
     $result = preg_replace($search, $replace, $subject);
     return $result !== $subject;
 }

 /**
  * Get the actual CPU time or the initial one if $ru is set.
  *
  * @deprecated in 1.20
  * @return float|null
  */
 function getCpuTime($ru = null)
 {
     wfDeprecated(__METHOD__, '1.20');
     if ($ru === null) {
         return $this->getTime('cpu');
     } else {
         # It theory we should use $ru here, but it always $wgRUstart that is passed here
         return $this->getInitialTime('cpu');
     }
 }

 /**
  * Returns true if the PATH_INFO ends with an extension other than a script
  * extension. This could confuse IE for scripts that send arbitrary data which
  * is not HTML but may be detected as such.
  *
  * Various past attempts to use the URL to make this check have generally
  * run up against the fact that CGI does not provide a standard method to
  * determine the URL. PATH_INFO may be mangled (e.g. if cgi.fix_pathinfo=0),
  * but only by prefixing it with the script name and maybe some other stuff,
  * the extension is not mangled. So this should be a reasonably portable
  * way to perform this security check.
  *
  * Also checks for anything that looks like a file extension at the end of
  * QUERY_STRING, since IE 6 and earlier will use this to get the file type
  * if there was no dot before the question mark (bug 28235).
  *
  * @deprecated Use checkUrlExtension().
  *
  * @param $extWhitelist array
  *
  * @return bool
  */
 public function isPathInfoBad($extWhitelist = array())
 {
     wfDeprecated(__METHOD__, '1.17');
     global $wgScriptExtension;
     $extWhitelist[] = ltrim($wgScriptExtension, '.');
     return IEUrlExtension::areServerVarsBad($_SERVER, $extWhitelist);
 }

 /**
  * Converts a Status object to an array suitable for addValue
  * @deprecated since 1.25, use ApiErrorFormatter::arrayFromStatus()
  * @param Status $status
  * @param string $errorType
  * @return array
  */
 public function convertStatusToArray($status, $errorType = 'error')
 {
     wfDeprecated(__METHOD__, '1.25');
     return $this->errorFormatter->arrayFromStatus($status, $errorType);
 }

 /**
  * Get the generators array mapping module names to class names
  * @deprecated since 1.21, list of generators is maintained by ApiPageSet
  * @return array array(modulename => classname)
  */
 public function getGenerators()
 {
     wfDeprecated(__METHOD__, '1.21');
     $gens = array();
     foreach ($this->mModuleMgr->getNamesWithClasses() as $name => $class) {
         if (is_subclass_of($class, 'ApiQueryGeneratorBase')) {
             $gens[$name] = $class;
         }
     }
     return $gens;
 }

 /**
  * Get a SHA-1 hash of a file in the local filesystem, in base-36 lower case
  * encoding, zero padded to 31 digits.
  *
  * 160 log 2 / log 36 = 30.95, so the 160-bit hash fills 31 digits in base 36
  * fairly neatly.
  *
  * @param $path string
  *
  * @return bool|string False on failure
  * @deprecated since 1.19
  */
 static function sha1Base36($path)
 {
     wfDeprecated(__METHOD__, '1.19');
     $fsFile = new FSFile($path);
     return $fsFile->getSha1Base36();
 }