text:
#ifndef VMWIDGETS_H
#define VMWIDGETS_H

#include "vmwidget.h"
#include "vmnumberformats.h"
#include "completers.h"

#include <QAction>
#include <QString>
#include <QLabel>
#include <QToolButton>
#include <QDateEdit>
#include <QTimeEdit>
#include <QLineEdit>
#include <QComboBox>
#include <QCheckBox>

//------------------------------------------------VM-ACTION-------------------------------------------------
class vmAction : public QAction, public vmWidget
{

public:
	inline vmAction ( const int index, QObject* parent = nullptr )
		: QAction ( parent ), vmWidget ( WT_ACTION, -1, index ) {}

	inline vmAction ( const int index, const QString& text, QObject* parent = nullptr )
		: QAction ( text, parent ), vmWidget ( WT_ACTION, -1, index ) {}

	inline vmAction ( const int index, const QIcon &icon, const QString& text, QObject* parent = nullptr )
		: QAction ( icon, text, parent ), vmWidget ( WT_ACTION, -1, index ) {}

	virtual ~vmAction ();

	inline void setLabel ( const QString& text ) { QAction::setText ( text ); }
};
//------------------------------------------------VM-ACTION-------------------------------------------------

//------------------------------------------------VM-ACTION-LABEL-------------------------------------------------
class vmActionLabel : public QToolButton, public vmWidget
{

public:
	explicit vmActionLabel ( QWidget* parent = nullptr );
	explicit vmActionLabel ( const QString& text, QWidget* parent = nullptr );
	explicit vmActionLabel ( vmAction* action, QWidget* parent = nullptr );

	virtual ~vmActionLabel ();

	inline QLatin1String qtClassName () const override { return QLatin1String ( "QToolButton" ); }
	QString defaultStyleSheet () const override;

	inline void setText ( const QString& text, const bool = false ) override { QToolButton::setText ( text ); }
	inline QString text () const override { return QToolButton::text (); }

	void setCallbackForLabelActivated ( const std::function<void ()>& func );
	// Programmatically call the callback generally called via user input
	inline void callLabelActivatedFunc () { if ( labelActivated_func ) labelActivated_func (); }
	QSize sizeHint () const override;
	QSize minimumSizeHint () const override;

protected:
	void init ( const bool b_action = true );

private:
	std::function<void ()> labelActivated_func;
};
//------------------------------------------------VM-ACTION-LABEL-------------------------------------------------

//------------------------------------------------VM-DATE-EDIT------------------------------------------------
class pvmDateEdit;
class vmDateEdit : public QWidget, public vmWidget
{

friend class pvmDateEdit;

public:
	vmDateEdit ( QWidget* parent = nullptr );
	virtual ~vmDateEdit ();

	void setID ( const int id );

	inline QLatin1String qtClassName () const override { return QLatin1String ( "QDateEdit" ); }
	QString defaultStyleSheet () const override;

	void setDate ( const vmNumber& date, const bool b_notify = false );
	const QDate date () const;
	inline void setText ( const QString& text, const bool b_notify = false ) override {
		setDate ( vmNumber ( text, VMNT_DATE ), b_notify );
	}
	inline QString text () const override { return vmNumber ( date () ).toDate ( vmNumber::VDF_HUMAN_DATE ); }

	void setEditable ( const bool editable ) override;
	void datesButtonMenuRequested ();

	static void execDateButtonsMenu ( const vmAction* const action, pvmDateEdit* dte );
	static void createDateButtonsMenu ( QWidget* parent = nullptr );
	static void updateDateButtonsMenu ();
	static void updateRecentUsedDates ( const vmNumber& date );

	inline QMenu* standardContextMenu () const override;
	void setTabOrder ( QWidget* formOwner, QWidget* prevWidget, QWidget* nextWidget );

private:
	pvmDateEdit* mDateEdit;
	QToolButton* mButton;
	static QMenu* menuDateButtons;

	friend void deleteMenuDateButtons ();
};
//------------------------------------------------VM-DATE-EDIT------------------------------------------------

//------------------------------------------------VM-TIME-EDIT------------------------------------------------
class vmTimeEdit : public QTimeEdit, public vmWidget
{

public:
	vmTimeEdit ( QWidget* parent = nullptr );
	virtual ~vmTimeEdit ();

	inline QLatin1String qtClassName () const override { return QLatin1String ( "QTimeEdit" ); }
	QString defaultStyleSheet () const override;

	void setTime ( const vmNumber& time, const bool b_notify = false );
	inline void setText ( const QString& text, const bool b_notify = false ) override { setTime ( vmNumber ( text, VMNT_TIME ), b_notify ); }
	inline QString text () const override { return vmNumber ( time () ).toTime (); }

	inline void setEditable ( const bool editable ) override {
		setReadOnly ( !editable );
		vmWidget::setEditable ( editable );
	}

protected:
	void keyPressEvent ( QKeyEvent* ) override;
	void focusInEvent ( QFocusEvent* ) override;
	void focusOutEvent ( QFocusEvent* ) override;

private:
	QTime mTimeBeforeFocus;
};
//------------------------------------------------VM-TIME-EDIT------------------------------------------------

//------------------------------------------------LINE-EDIT-LINK----------------------------------------------
class vmLineEdit : public QLineEdit, public vmWidget
{

friend class vmLineEditWithButton;

public:
	explicit vmLineEdit ( QWidget* parent = nullptr, QWidget* ownerWindow = nullptr );
	virtual ~vmLineEdit ();

	inline QLatin1String qtClassName () const override { return QLatin1String ( "QLineEdit" ); }
	QString defaultStyleSheet () const override;
	void highlight ( const VMColors vm_color, const QString& str = QString::null ) override;

	void setText ( const QString& text, const bool b_notify = false ) override;
	inline QString text () const override { return QLineEdit::text (); }
	void setTrackingEnabled ( const bool b_tracking );

	void setEditable ( const bool editable ) override;
	inline void setCallbackForMouseClicked ( const std::function<void ( const vmLineEdit* const )>& func ) { mouseClicked_func = func; }

	QMenu* standardContextMenu () const override;

	void completerClickReceived ( const QString& value );
	void updateText ();

	inline const QString& textBeforeChange () const { return mCurrentText; }
	inline void setCurrentText ( const QString& text ) { mCurrentText = text; }

protected:
	void keyPressEvent ( QKeyEvent* ) override;
	void keyReleaseEvent ( QKeyEvent* ) override;
	void mouseMoveEvent ( QMouseEvent* ) override;
	void mouseReleaseEvent ( QMouseEvent* ) override;
	void contextMenuEvent ( QContextMenuEvent* ) override;
	void focusInEvent ( QFocusEvent* ) override;
	void focusOutEvent ( QFocusEvent* ) override;

private:
	bool mCtrlKey;
	bool mCursorChanged;
	bool b_widgetCannotGetFocus;
	bool mbTrack;
	bool mbButtonClicked;
	QString mCurrentText; // Can be used as old value by contentsAltered_func because it's only updated after the call to it. Retrieve it via textBeforeChange ()

	std::function<void ( const vmLineEdit* const )> mouseClicked_func;
};
//------------------------------------------------LINE-EDIT-LINK----------------------------------------------

//------------------------------------------------VM-LINE-EDIT-BUTTON-----------------------------------------------
class vmLineEditWithButton : public QWidget, public vmWidget
{

public:

	enum LINE_EDIT_BUTTON_TYPE { LEBT_NO_BUTTON = 0, LEBT_CALC_BUTTON = 0x20, LEBT_DIALOG_BUTTON = 0x40, LEBT_CUSTOM_BUTTOM = 0x80 };

	vmLineEditWithButton ( QWidget* parent = nullptr );
	virtual ~vmLineEditWithButton ();

	inline QLatin1String qtClassName () const override { return QLatin1String ( "QLineEdit" ); }
	inline QString defaultStyleSheet () const override { return mLineEdit->defaultStyleSheet () ; }
	inline void highlight ( const VMColors wm_color, const QString& str = QString::null ) override { mLineEdit->highlight ( wm_color, str ); }
	void setEditable ( const bool editable ) override;
	inline void setText ( const QString& text, const bool b_notify = false ) override { mLineEdit->setText ( text, b_notify ); }
	inline QString text () const override { return mLineEdit->QLineEdit::text (); }

	void setButtonType ( const LINE_EDIT_BUTTON_TYPE type );
	void setButtonIcon ( const QIcon& icon ) { mButton->setIcon ( icon ); }
	inline void setButtonTooltip ( const QString& str_tip ) { mButton->setToolTip ( str_tip ); }

	inline vmLineEdit* lineControl () const { return mLineEdit; }
	inline bool wasButtonClicked () const { return mLineEdit->mbButtonClicked; }

	inline void setCallbackForButtonClicked ( const std::function<void()>& func ) { buttonclicked_func = func; }
	inline QMenu* standardContextMenu () const override { return mLineEdit->standardContextMenu (); }

private:
	vmLineEdit* mLineEdit;
	QToolButton* mButton;
	LINE_EDIT_BUTTON_TYPE mBtnType;
	std::function<void()> buttonclicked_func;

	void execButtonAction ();
};
//------------------------------------------------VM-LINE-EDIT-BUTTON------------------------------------------------

//------------------------------------------------VM-COMBO-BOX------------------------------------------------
class vmComboBox : public QComboBox, public vmWidget
{

public:
	vmComboBox ( QWidget* parent = nullptr );
	virtual ~vmComboBox ();

	inline void setID ( const int id )
	{
		mLineEdit->setID ( id );
		vmWidget::setID ( id );
	}

	inline QLatin1String qtClassName () const override { return QLatin1String ( "QComboBox" ); }
	QString defaultStyleSheet () const override;
	void highlight ( const VMColors vm_color, const QString& str = QString::null ) override;

	void setText ( const QString& text, const bool b_notify = false ) override;
	inline QString text () const override { return mLineEdit->QLineEdit::text (); }

	void setCompleter ( const vmCompleters::COMPLETER_CATEGORIES completer );
	void setIgnoreChanges ( const bool b_ignore );
	void setEditable ( const bool editable ) override;

	/* Will check for existance of text and only append it if there is no match
	 * For additions that we know there is no way of a match, call QComboBox::addItem dicrectly,
	 * for it will be faster
	 */
	void insertItem ( const QString& text, const int idx = -1, const bool b_check = true );

	// The receiver should retrieve the line edit's parent to find the vmComboBox owning the sender of the signal
	inline void setCallbackForContentsAltered ( const std::function<void ( const vmWidget* const )>& func ) override
	{
		vmWidget::setCallbackForContentsAltered ( func );
		mLineEdit->setCallbackForContentsAltered ( func );
	}

	inline void setCallbackForActivated ( const std::function<void ( const int )>& func ) { indexChanged_func = func; }
	inline void setCallbackForIndexChanged ( const std::function<void ( const int )>& func ) { indexChanged_func = func; }
	inline void setCallbackForEnterKeyPressed ( const std::function<void ()>& func ) { keyEnter_func = func; }
	inline void setCallbackForEscKeyPressed ( const std::function<void ()>& func ) { keyEsc_func = func; }

	inline vmLineEdit* editor () const { return mLineEdit; }

protected:
	void focusOutEvent ( QFocusEvent* ) override;
	void keyPressEvent ( QKeyEvent* ) override;
	void focusInEvent ( QFocusEvent* ) override;
	void wheelEvent ( QWheelEvent* ) override;

private:
	bool mbIgnoreChanges;
	bool mbKeyEnterPressedOnce;
	bool mbKeyEscPressedOnce;

	vmLineEdit* mLineEdit;

	std::function<void ( const vmLineEdit* const )> textAltered_func;
	std::function<void ( const int )> indexChanged_func;
	std::function<void ( const int )> activated_func;
	std::function<void ()> keyEnter_func;
	std::function<void ()> keyEsc_func;

	void currentIndexChanged_slot ( const int idx );
};
//------------------------------------------------VM-COMBO-BOX------------------------------------------------

//------------------------------------------------VM-CHECK-BOX------------------------------------------------
class vmCheckBox : public QCheckBox, public vmWidget
{

public:
	explicit vmCheckBox ( QWidget* parent = nullptr );
	vmCheckBox ( const QString& text, QWidget* parent = nullptr );
	virtual ~vmCheckBox ();

	inline QLatin1String qtClassName () const { return QLatin1String ( "QCheckBox" ); }
	QString defaultStyleSheet () const;

	inline void setChecked ( const bool checked, const bool b_notify = false )
	{
		setText ( checked ? CHR_ONE : CHR_ZERO, b_notify );
	}

	void setText ( const QString& text, const bool b_notify = false );

	inline QString text () const { return isChecked () ? CHR_ONE : CHR_ZERO; }
	void setEditable ( const bool editable );

	// Qt's uic calls setText, which render the controle labelless because we use the same function name, which trumps the base's name.
	// Every controler used in the source must call setLabel if created by Qt's UI tools. Otherwise, set the label in the constructor
	inline void setLabel ( const QString& label ) { QCheckBox::setText ( label ); }
};
//------------------------------------------------VM-CHECK-BOX------------------------------------------------

#endif // VMWIDGETS_H


text:
@interface MLBMovieReview : MLBBaseModel

@property (nonatomic, strong) NSString *reviewId;
@property (nonatomic, strong) NSString *movieId;
@property (nonatomic, strong) NSString *content;
@property (nonatomic, strong) NSString *score;
@property (nonatomic, assign) NSInteger praiseNum;
@property (nonatomic, strong) NSString *sort;
@property (nonatomic, strong) NSString *inputDate;
@property (nonatomic, strong) MLBAuthor *author;

@end

redpajama_set_name: RedPajamaGithub


text:
<?php
namespace Boekkooi\Bundle\DoctrineJackBundle\EventListener;

use Doctrine\Common\EventSubscriber;
use Doctrine\Common\Persistence\Event\LoadClassMetadataEventArgs;
use Doctrine\ORM\Events;

/**
 * @author Warnar Boekkooi <warnar@boekkooi.net>
 */
class DiscriminatorMapListener implements EventSubscriber
{
    /**
     * @var array
     */
    private $entityMaps = array();

    public function __construct(array $entityMaps)
    {
        $this->mergeEntityMaps($entityMaps);
    }

    /**
     * {@inheritdoc}
     */
    public function getSubscribedEvents()
    {
        return array(
            Events::loadClassMetadata
        );
    }

    public function loadClassMetadata(LoadClassMetadataEventArgs $event)
    {
        if (empty($this->entityMaps)) {
            return;
        }

        /** @var \Doctrine\ORM\Mapping\ClassMetadata $metadata */
        $metadata = $event->getClassMetadata();
        if (!method_exists($metadata, 'setDiscriminatorMap')) {
            return;
        }

        if (!array_key_exists($metadata->getName(), $this->entityMaps)) {
            return;
        }

        $metadata->setDiscriminatorMap($this->entityMaps[$metadata->getName()]);
    }

    public function getEntityMaps()
    {
        return $this->entityMaps;
    }

    protected function mergeEntityMaps(array $entityMaps)
    {
        foreach ($entityMaps as $className => $map) {
            $className = ltrim($className, '\\');
            if (!isset($this->entityMaps[$className])) {
                $this->entityMaps[$className] = array();
            }

            foreach ($map as $name => $cls) {
                $this->entityMaps[$className][$name] = ltrim($cls, '\\');
            }
        }
    }
}


text:
<html>
    <body>
        <button class="open-popup" onclick="lastPopup = window.open(document.location.href, '_blank');">open popup</button>
        <button class="open-popup-2" onclick="lastPopup = window.open(document.location.href, '_blank');">open popup</button>

        <button class="close-self" onclick="window.close();">close popup</button>
    </body>
</html>


text:
<?php

use lithium\action\Dispatcher;
use lithium\core\Environment;
use lithium\action\Response;
use lithium\net\http\Media;
use lithium\util\Set;
use lithium\util\String;
use Handlebars\Autoloader;

Media::type('default', null, array(
	'view' => 'lithium\template\View',
	'paths' => array(
		'template' => array(
			LITHIUM_APP_PATH . '/views/{:controller}/{:template}.{:type}.php',
			RADIUM_PATH . '/views/{:controller}/{:template}.{:type}.php',
			'{:library}/views/{:controller}/{:template}.{:type}.php',
		),
		'layout' => array(
			LITHIUM_APP_PATH . '/views/layouts/{:layout}.{:type}.php',
			RADIUM_PATH . '/views/layouts/{:layout}.{:type}.php',
			'{:library}/views/layouts/{:layout}.{:type}.php',
		),
		'element' => array(
			LITHIUM_APP_PATH . '/views/elements/{:template}.{:type}.php',
			RADIUM_PATH . '/views/elements/{:template}.{:type}.php',
			'{:library}/views/elements/{:template}.{:type}.php',
		),
		'widget' => array(
			LITHIUM_APP_PATH . '/views/widgets/{:template}.{:type}.php',
			RADIUM_PATH . '/views/widgets/{:template}.{:type}.php',
			'{:library}/views/widgets/{:template}.{:type}.php',
		),
    )
));

Media::type('rss', 'application/rss+xml');
Media::type('csv', 'application/csv', array('encode' => function($data) {
	$scaffold = Environment::get('scaffold');
	if ($scaffold) {
		$model = $scaffold['model'];
		$fields = $model::schema()->names();
	}

	ob_start();
	$out = fopen('php://output', 'w');

	if ($scaffold && isset($data['object'])) {
		$object = $data['object'] ? : array();
		$replace = Set::flatten(array_merge(compact('scaffold'), $object));
		$name = String::insert('{:scaffold.human} - {:_id}: {:name}.csv', $replace);
		foreach($fields as $field) {
			fputcsv($out, array($field, isset($object[$field]) ? $object[$field] : ''));
		}
	}

	if ($scaffold && isset($data['objects'])) {
		$objects = $data['objects'] ? : array();
		$name = String::insert('{:slug}.csv', $scaffold);
		fputcsv($out, array_values($fields));
		foreach($data['objects'] as $row) {
			fputcsv($out, Set::flatten($row));
		}
	}

	if (!$scaffold && $data) {
		$name = 'temp.csv';
		foreach($data as $row) {
			fputcsv($out, Set::flatten($row));
		}
	}

	fclose($out);
	header(sprintf('Content-Disposition: attachment; filename="%s"', $name));
	return ob_get_clean();
}));

// Libraries::add('Handlebars', array(
//     // "prefix" => "Handlebars_",
//     // "includePath" => LITHIUM_LIBRARY_PATH, // or LITHIUM_APP_PATH . '/libraries'
//     // "bootstrap" => "Loader/Autoloader.php",
//     // "loader" => array("Handlebars", "register"),
//     // "transform" => function($class) { return str_replace("_", "/", $class) . ".php"; }
// ));

require RADIUM_PATH . '/libraries/Handlebars/Autoloader.php';
Autoloader::register();

/*
 * this filter allows automatic linking and loading of assets from `webroot` folder
 */
Dispatcher::applyFilter('_callable', function($self, $params, $chain) {
	list($library, $asset) = explode('/', ltrim($params['request']->url, '/'), 2) + array("", "");
	if ($asset && $library == 'radium' && ($path = Media::webroot($library)) && file_exists($file = "{$path}/{$asset}")) {
		return function() use ($file) {
			$info = pathinfo($file);
			$media = Media::type($info['extension']);
			$content = (array) $media['content'];

			return new Response(array(
				'headers' => array('Content-type' => reset($content)),
				'body' => file_get_contents($file)
			));
		};
	}
	return $chain->next($self, $params, $chain);
});


text:
<?php

/**
 * Created by PhpStorm.
 * User: taren
 * Date: 23-6-2017
 * Time: 19:23
 */
class AuthTemplate
{
  function __construct()
  {
  }

  public function getLoginTemplate(){
    return "
    <form class=\"callout text-center\" method='post'>

Login

    Email
    <input type=\"email\" id=\"email\" name=\"email\" placeholder=\"Email\">

    Password
    <input type=\"password\" id=\"pass\" name=\"password\" placeholder=\"Password\">

  <input class=\"button expanded\" type=\"submit\" value=\"Sign In\">
</form>

    ";
  }
}


text:
require 'rails_helper'

RSpec.describe Gloss, :type => :model do
  it_behaves_like "searchable"
end


text:
namespace RiotSharp.Test
{
    public class RateLimiterTestBase : CommonTestBase
    {
    }
}


text:
package com.jarvis.cache;

import com.jarvis.cache.to.CacheKeyTO;
import com.jarvis.cache.to.CacheWrapper;

/**
 *
 */
public class MSetParam {

    private CacheKeyTO cacheKey;

    private CacheWrapper<Object> result;

    public MSetParam(CacheKeyTO cacheKey, CacheWrapper<Object> result) {
        this.cacheKey = cacheKey;
        this.result = result;
    }

    public CacheKeyTO getCacheKey() {
        return cacheKey;
    }

    public CacheWrapper<Object> getResult() {
        return result;
    }
}


text:
apache-streams artifacts include streams source code, convenience jars by module, and a binary/byte-code release

###NOTE:

Prior to your first release, you'll need to refer to [Release Setup Information](/release-setup.html).

Prior to each release you perform, you'll need to refer to [Release Preparation](/release-preparation.html).

As a streams release manager, you probably want to use the release.sh and publish-rc.sh scripts in the root of apache-streams.

To perform a release manually, or to better understand what's going on, read the instructions below.

###Common Release Steps

1. Environment setup for releasing artifacts (same for SNAPSHOTs and releases)

    1. Use the latest Sun 1.8.x JDK
    2. Use Maven 3.6.3 or later
    3. Make sure the [Release Setup](release-setup.html) steps have been performed.

2. Prepare the source for release:

     1. Cleanup JIRA so the Fix Version in issues resolved since the last release includes this release version correctly.
     2. Update the text files in a working copy of the project root -
         1. Update the CHANGELOG based on the Text release reports from JIRA.
         2. Review and update README.md if needed.
         3. Commit any changes back to git
     3. Stage any Roadmap or Release landing pages on the site.

3. Create a release candidate branch from master.

   X should start at 1 and increment if early release candidates fail to complete the release cycle.

        git checkout master
        git branch ${project.name}-${project.version}-rcX
        git checkout ${project.name}-${project.version}-rcX

4. Verify the source has the required license headers before trying to release:

        mvn -Papache-release clean apache-rat:check -e -DskipTests

5. Do a dry run of the release:prepare step:

        mvn -Papache-release release:prepare -DautoVersionSubmodules=true -DdryRun=true

    - The dry run will not commit any changes back to SCM and gives you the opportunity to verify that the release process will complete as expected. You will be prompted for the following information :

        * Release version - take the default (should be ${project.version})
        * SCM release tag - *DO NOT TAKE THE DEFAULT*  - ${project.artifactId}-${project.version}-rcX
        * New development version - take the default (should be ${project.version}-SNAPSHOT)
        * GPG Passphrase

    - *If you cancel a release:prepare before it updates the pom.xml versions, then use the release:clean goal to just remove the extra files that were created.*

    - The Maven release plugin checks for SNAPSHOT dependencies in pom's. It will not complete the prepare goal until all SNAPSHOT dependencies are resolved.

6. Verify that the release process completed as expected

    1. The release plugin will create pom.xml.tag files which contain the changes that would have been committed to SVN. The only differences between pom.xml.tag and it's corresponding pom.xml file should be the version number.
    2. Check release.properties and make sure that the scm properties have the right version. Sometimes the scm location can be the previous version not the next version.
    3. Verify signatures ([Verifying release signatures](#verify_signatures))

7. Cleanup the release prepare files again:

        mvn -Papache-release release:clean

8. Prepare the release

    1. Run the "release:prepare" step for real this time. You'll be prompted for the same version information.

            mvn -Papache-release -U clean release:prepare -DautoVersionSubmodules=true

    2. Backup (zip or tar) your local release candidate directory in case you need to rollback the release after the next step is performed.

9. Perform the release

    * This step will create a maven staging repository and site for use in testing and voting.

            mvn -Papache-release -Darguments='-Dmaven.test.skip.exec=true' release:perform -Dgoals=deploy -DlocalRepoDirectory=. -DlocalCheckout=true

    * If your local OS userid doesn't match your Apache userid, then you'll have to also override the value provided by the OS to Maven for the site-deploy step to work. This is known to work for Linux, but not for Mac and unknown for Windows.*

            -Duser.name=[your_apache_uid]

10. Verify the Nexus release artifacts

    1. Verify the staged artifacts in the nexus repo
        * https://repository.apache.org/index.html
        * Staging repositories (under Build Promotion) --> Name column --> org.apache.streams
        * Navigate through the artifact tree and make sure that all javadoc, sources, tests, jars, ... have .asc (GPG signature) and .md5 files. See http://people.apache.org/~henkp/repo/faq.html and http://www.apache.org/dev/release-signing.html#openpgp-ascii-detach-sig

    2. Close the nexus staging repo
        * https://repository.apache.org/index.html
        * Staging repositories (under Build Promotion) --> Name column --> org.apache.streams
        * Click checkbox for the open staging repo (org.apache.streams-XXX) and press Close in the menu bar.

11. Put the release candidate up for a vote

     1. Create a VOTE email thread on dev@ to record votes as replies
     2. Create a DISCUSS email thread on dev@ for any vote questions
     3. Perform a review of the release and cast your vote. See the following for more details on Apache releases
           [http://www.apache.org/dev/release.html](http://www.apache.org/dev/release.html)
     4. A -1 vote does not necessarily mean that the vote must be redone, however it is usually a good idea to rollback the release if a -1 vote is received. See - Recovering from a vetoed release
     5. After the vote has been open for at least 72 hours, has at least three +1 PMC votes and no -1 votes, then post the results to the vote thread by -
         * reply to the initial email and prepend to the original subject "[RESULT]"
         * Include a list of everyone who voted +1, 0 or -1.
     6. Promote the staged nexus artifacts
         * https://repository.apache.org/index.html
         * Staging repositories (under Build Promotion) --> Name column --> org.apache.streams
         * Click checkbox of the closed staging repo (org.apache.streams-XXX) and select Release.

12. Complete the release

    1. Copy the source artifacts over to the distribution area

            svn co https://dist.apache.org/repos/dist/release/streams/releases ./streams-releases  (KEEP this directory until after the release process has been completed)
            cd ./streams-releases
            mkdir ${project.version}
            cd ./${project.version}
            wget https://repository.apache.org/content/repositories/releases/org/apache/streams/${project.name}/${project.version}/${project.name}-${project.version}-source-release.zip
            wget https://repository.apache.org/content/repositories/releases/org/apache/streams/${project.name}/${project.version}/${project.name}-${project.version}-source-release.zip.asc
            wget https://repository.apache.org/content/repositories/releases/org/apache/streams/${project.name}/${project.version}/${project.name}-${project.version}-source-release.zip.md5
            wget https://repository.apache.org/content/repositories/releases/org/apache/streams/${project.name}/${project.version}/${project.name}-${project.version}-source-release.zip.sha1
            svn add ${project.name}-*
            svn commit -m "Committing Source Release for ${project.name}-${project.version}

    2. Create an official release tag from the successful release candidate tag.

            git checkout ${project.name}-${project.version}-rcX
            git tag -a ${project.name}-${project.version} -m 'release tag ${project.name}-${project.version}'
            git push origin :refs/tags/streams-project-${project.version}

    3. Update the staged website
        *  Update the downloads page (downloads.md) to add new version using the mirrored URLs
        *  Modify the URL for the prior release to the archived URL for the release

    4.  Publish the website (see [website](website.html "Website Management"))
        *  WAIT 24hrs after committing releases for mirrors to replicate
        *  Publish updates to the download page

    5.  Delete the prior versions
        *  Navigate to the release directories checked out in the prior steps
        *  Delete the prior release artifacts using the svn delete command
        *  Commit the deletion

14. Update the JIRA versions page to close all issues, mark the version as "released", and set the date to the date that the release was approved. You may also need to make a new release entry for the next release.

15. Announcing the release
       * Make a news announcement on the streams homepage.
       * Make an announcement about the release on the dev@streams.apache.org, and announce@apache.org list as per the Apache Announcement Mailing Lists page)

####Recovering from a vetoed release

1. Reply to the initial vote email and prepend to the original subject -

     [CANCELED]

2. Clean the release prepare files and hard reset the release candidate branch.

        mvn -P apache-release release:clean

3. Delete the git tag created by the release:perform step -

        git tag -d streams-project-${project.version}-rcX
        git push origin :refs/tags/streams-project-${project.version}-rcX

4. Delete the build artifacts on people & www

        rm -rfv /www/people.apache.org/builds/streams/${project.version}
        rm -rfv /www/www.apache.org/dist/streams/${project.version}

5. Drop the nexus staging repo

    1. https://repository.apache.org/index.html
    2. Enterprise --> Staging
    3. Staging tab --> Name column --> org.apache.streams
    4. Right click on the closed staging repo (org.apache.streams-XXX) and select Drop.

5. Remove the staged site

6. Make the required updates that caused the vote to be canceled during the next release cycle

####Verifying release signatures
On unix platforms the following command can be executed -

    for file in `find . -type f -iname '*.asc'`
    do
        gpg --verify ${file}
    done

You'll need to look at the output to ensure it contains only good signatures -

gpg: Good signature from ...
gpg: Signature made ...

####Combined Release
In order to perform a combined release of the streams-master and streams-project trunks, do the following:

  *  Perform Steps 1-9 of the [release](#release-steps) for apache-streams and apache-streams-examples
      *  Do NOT perform step 10 until steps 1-9 have been completed for BOTH projects
      *  Build the streams-master FIRST
      *  When prompted to change dependencies on SNAPSHOTs, do so to the corresponding releases that you just built

  *  Execute the remaining steps using the following e-mail template

          to: dev@streams.apache.org
          subject: [VOTE] Apache Streams ${release.version} Release Candidate

          I've created a combined ${release.version} release candidate, with the
          following artifacts up for a vote:

          apache-streams source tag (r${release.version}):
          https://gitbox.apache.org/repos/asf?p=streams.git;a=commit;h=...

          apache-streams-examples source tag (r${release.version}):
          https://gitbox.apache.org/repos/asf?p=streams-examples.git;a=commit;h=...

          Maven staging repo:
          https://repository.apache.org/content/repositories/${release.project.repository}
          https://repository.apache.org/content/repositories/${release.examples.repository}

          Source releases:
          https://repository.apache.org/content/repositories/${release.project.repository}/org/apache/rave/rave-project/${release.version}/streams-project-${release.version}-source-release.zip
          https://repository.apache.org/content/repositories/${release.project.repository}/org/apache/rave/rave-project/${release.version}/streams-project-${release.version}-source-release.zip

          Checksums of streams-project-${release.version}-source-release.zip:
          MD5: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          SHA1: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

          Checksums of streams-examples-${release.version}-source-release.zip:
          MD5: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          SHA1: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

          Release artifacts are signed with the following key:
          https://people.apache.org/keys/committer/...

          Please take the time to verify the artifacts before casting your vote.

          Vote will be open for 72 hours.

          [ ] +1  approve
          [ ] +0  no opinion
          [ ] -1  disapprove (and reason why)

###### Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
    <title>Statistics of compound:apr in UD_Vietnamese-VTB</title>
    <link rel="root" href=""/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css">
    <link rel="stylesheet" type="text/css" href="../../css/jquery-ui-redmond.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/style.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/style-vis.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/hint.css"/>

          home

          edit page
          issue tracker

          <gcse:search></gcse:search>

        This page pertains to UD version 2.

            It appears that you have Javascript disabled.
            Please consider enabling Javascript for this page to see the visualizations.

Treebank Statistics: UD_Vietnamese-VTB: Relations: compound:apr

This relation is a language-specific subtype of <tt>compound</tt>.
There are also 11 other language-specific subtypes of compound: <tt>compound:adj</tt>, <tt>compound:amod</tt>, <tt>compound:atov</tt>, <tt>compound:dir</tt>, <tt>compound:pron</tt>, <tt>compound:prt</tt>, <tt>compound:redup</tt>, <tt>compound:svc</tt>, <tt>compound:verbnoun</tt>, <tt>compound:vmod</tt>, <tt>compound:z</tt>.

2 nodes (0%) are attached to their parents as compound:apr.

2 instances of compound:apr (100%) are left-to-right (parent precedes child).
Average distance between parent and child is 1.

The following 2 pairs of parts of speech are connected with compound:apr: <tt>ADJ</tt>-<tt>ADV</tt> (1; 50% instances), <tt>ADV</tt>-<tt>ADJ</tt> (1; 50% instances).

# visual-style 12	bgColor:blue
# visual-style 12	fgColor:white
# visual-style 11	bgColor:blue
# visual-style 11	fgColor:white
# visual-style 11 12 compound:apr	color:blue
1	Nhìn	nhìn	VERB	V	_	5	advcl	_	_
2	bên	bên	ADP	Pre	_	3	case	_	_
3	ngoài	ngoài	NOUN	N	_	1	obl	_	_
4	có thể	có thể	AUX	AUX	_	5	aux	_	_
5	thấy	thấy	VERB	V	_	0	root	_	_
6	cái	cái	NOUN	Nc	_	7	clf:det	_	_
7	đà	đà	NOUN	N	_	10	nsubj	_	_
8	ngang	ngang	ADJ	Adj	_	7	amod	_	_
9	đã	đã	ADV	Adv	_	10	advmod	_	_
10	nứt	nứt	VERB	V	_	5	ccomp	_	_
11	võng	võng	ADJ	Adj	_	10	xcomp	_	_
12	xuống	xuống	ADV	Adv	_	11	compound:apr	_	_
13	như	như	SCONJ	SC	_	15	case	_	_
14	sắp	sắp	ADV	Adv	_	15	advmod	_	_
15	gãy	gãy	VERB	V	_	11	advcl	_	_
16	đôi	đôi	NUM	Num	_	15	nmod	_	_
17	.	.	PUNCT	.	_	5	punct	_	_

# visual-style 19	bgColor:blue
# visual-style 19	fgColor:white
# visual-style 18	bgColor:blue
# visual-style 18	fgColor:white
# visual-style 18 19 compound:apr	color:blue
1	Ông	ông	NOUN	Nc	_	2	clf:det	_	_
2	Trường	Trường	PROPN	NNP	_	3	nsubj	_	_
3	nói	nói	VERB	V	_	0	root	_	_
4	vui	vui	ADJ	Adj	_	3	advmod:adj	_	_
5	:	:	PUNCT	:	_	16	punct	_	_
6	"	"	PUNCT	``	_	16	punct	_	_
7	Chỉ	chỉ	ADV	Adv	_	8	advmod	_	_
8	khi	khi	NOUN	N	_	16	obl:tmod	_	_
9	lợn gà	lợn gà	NOUN	N	_	10	nsubj	_	_
10	nói	nói	VERB	V	_	8	acl:tmod	_	_
11	được	được	ADV	Adv	_	10	advmod	_	_
12	ngoại ngữ	ngoại ngữ	NOUN	N	_	10	obj	_	_
13	thì	thì	SCONJ	SC	_	16	mark	_	_
14	chúng tôi	chúng tôi	PRON	Pro	_	16	nsubj	_	_
15	mới	mới	ADV	Adv	_	16	advmod	_	_
16	biết	biết	VERB	V	_	3	parataxis	_	_
17	đó	đó	PRON	Pro	_	20	nsubj	_	_
18	không	không	ADV	Adv	_	20	advmod:neg	_	_
19	phải	phải	ADJ	Adj	_	18	compound:apr	_	_
20	hàng	hàng	NOUN	N	_	16	ccomp	_	_
21	nội địa	nội địa	NOUN	N	_	20	nmod	_	_
22	"	"	PUNCT	``	_	16	punct	_	_
23	.	.	PUNCT	.	_	3	punct	_	_

© 2014–2021
            Universal Dependencies contributors.
            Site powered by Annodoc and brat
.


text:
from msrest.serialization import Model

class MetricSpecification(Model):
    """Metric specification of operation.

    :param name: Name of metric specification.
    :type name: str
    :param display_name: Display name of metric specification.
    :type display_name: str
    :param display_description: Display description of metric specification.
    :type display_description: str
    :param unit: Unit could be Bytes or Count.
    :type unit: str
    :param dimensions: Dimensions of blobs, including blob type and access
     tier.
    :type dimensions: list[~azure.mgmt.storage.v2017_06_01.models.Dimension]
    :param aggregation_type: Aggregation type could be Average.
    :type aggregation_type: str
    :param fill_gap_with_zero: The property to decide fill gap with zero or
     not.
    :type fill_gap_with_zero: bool
    :param category: The category this metric specification belong to, could
     be Capacity.
    :type category: str
    :param resource_id_dimension_name_override: Account Resource Id.
    :type resource_id_dimension_name_override: str
    """

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display_name': {'key': 'displayName', 'type': 'str'},
        'display_description': {'key': 'displayDescription', 'type': 'str'},
        'unit': {'key': 'unit', 'type': 'str'},
        'dimensions': {'key': 'dimensions', 'type': '[Dimension]'},
        'aggregation_type': {'key': 'aggregationType', 'type': 'str'},
        'fill_gap_with_zero': {'key': 'fillGapWithZero', 'type': 'bool'},
        'category': {'key': 'category', 'type': 'str'},
        'resource_id_dimension_name_override': {'key': 'resourceIdDimensionNameOverride', 'type': 'str'},
    }

    def __init__(self, name=None, display_name=None, display_description=None, unit=None, dimensions=None, aggregation_type=None, fill_gap_with_zero=None, category=None, resource_id_dimension_name_override=None):
        super(MetricSpecification, self).__init__()
        self.name = name
        self.display_name = display_name
        self.display_description = display_description
        self.unit = unit
        self.dimensions = dimensions
        self.aggregation_type = aggregation_type
        self.fill_gap_with_zero = fill_gap_with_zero
        self.category = category
        self.resource_id_dimension_name_override = resource_id_dimension_name_override


text:
layout: page
title: Maynard - West Wedding
date: 2016-05-24
author: Alan Patel
tags: weekly links, java
status: published
summary: Aliquam mollis tempus convallis. Pellentesque eu sodales nibh.
banner: images/banner/meeting-01.jpg
booking:
  startDate: 05/01/2016
  endDate: 05/03/2016
  ctyhocn: GALTNHX
  groupCode: MWW
published: true
---
Aenean vestibulum tempor purus, vitae interdum ante feugiat sit amet. Mauris ante ligula, rutrum et sem sed, hendrerit commodo dolor. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Sed eget magna vitae ipsum consectetur interdum vel eu ex. Morbi varius diam sed nulla dictum cursus. Phasellus eget justo eget magna pellentesque molestie. In condimentum et nunc porta ultricies. Cras nisl dolor, volutpat eu arcu non, venenatis porta tellus. Maecenas ornare sollicitudin magna quis tristique. Nulla tempus feugiat dui. Phasellus nec venenatis lacus. Vivamus in nulla felis. Suspendisse porttitor mauris nec sodales dictum.

1 Cras nec mi in eros viverra tristique
1 Vivamus in ante ut felis rhoncus facilisis id non urna
1 Quisque id elit vestibulum, convallis est et, ultricies velit.

Phasellus laoreet, augue at euismod tincidunt, lectus leo consequat arcu, iaculis volutpat mauris nisi a enim. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Mauris eu ligula quis arcu finibus ultrices sit amet vel sapien. Phasellus elementum ex at elit tempus dictum. Morbi purus dui, tristique sit amet purus eget, ullamcorper convallis lorem. Curabitur massa enim, condimentum non massa ut, ullamcorper volutpat libero. Integer sit amet ligula vehicula, varius massa mattis, ultrices mauris. Praesent aliquet ultricies purus ac maximus. Nulla vestibulum dapibus cursus. Duis sit amet leo pulvinar, interdum ligula id, laoreet augue. In quis urna suscipit, dignissim turpis sit amet, viverra felis.


text:
package org.butterfaces.component.renderkit.html_basic.text.util;

import org.butterfaces.component.html.text.HtmlTags;
import org.butterfaces.util.StringUtils;
import org.butterfaces.util.StringUtils;

import java.util.Arrays;
import java.util.List;

public class FreeTextSeparators {

    public static List<String> getFreeTextSeparators(HtmlTags tags) {
        final String confirmKeys = tags.getConfirmKeys();

        if (StringUtils.isNotEmpty(confirmKeys)) {
            return Arrays.asList(confirmKeys.split("(?)"));
        }

        return Arrays.asList(",", " ");

    }
}


text:
using Spyder.Client.Common;

namespace Spyder.Client.Scripting
{
    public class StillElement : ScriptElement
    {
        public Content Content
        {
            get
            {
                if (Contents == null || Contents.Count < 1)
                    return null;
                else
                    return Contents[0];
            }
        }

        public string FileName
        {
            get { return Content?.Name; }
        }
    }
}


text:
<body class="<?= empty($this->params['bodyclass'])?'page-header-fixed':$this->params['bodyclass']; ?>">
<?php $this->beginBody();?>
<?php $this->beginContent(dirname(__FILE__).'/blocks/header.php'); ?>
<?php $this->endContent();?>

	<?php $this->beginContent(dirname(__FILE__).'/blocks/sidebar.php'); ?>
	<?php $this->endContent();?>

							<button type="button" class="close" data-dismiss="modal" aria-hidden="true"></button>

Modal title

							 Widget settings form goes here

							<button type="button" class="btn btn-success">Save changes</button>
							<button type="button" class="btn btn-default" data-dismiss="modal">Close</button>

			<?php
				$this->beginContent(dirname(__FILE__).'/blocks/page_header.php');
				$this->endContent();
			?>
			<?= $content; ?>

<?php
$this->beginContent(dirname(__FILE__).'/blocks/footer.php');
$this->endContent();
?>
<?php $this->endBody() ?>


text:
module Versionist
  class NewPresenterGenerator < Rails::Generators::NamedBase
    include InflectorFixes
    include RspecHelper

    desc "creates a new presenter for an existing API version"
    source_root File.expand_path('../templates', __FILE__)

    argument :module_name, :type => :string

    def new_presenter
      in_root do
        raise "API module namespace #{module_name} doesn't exist. Please run \'rails generate versionist:new_api_version\' generator first" if !File.exists?("app/presenters/#{module_name_for_path(module_name)}")
        template 'new_presenter.rb', File.join("app", "presenters", "#{module_name_for_path(module_name)}", "#{file_name}_presenter.rb")
      end
    end

    def new_presenter_test
      in_root do
        case Versionist.configuration.configured_test_framework
        when :test_unit
          if Versionist.older_than_rails_5?
            template 'new_presenter_test.rb', File.join("test", "presenters", "#{module_name_for_path(module_name)}", "#{file_name}_presenter_test.rb")
          else
            template 'new_presenter_test_rails_5.rb', File.join("test", "presenters", "#{module_name_for_path(module_name)}", "#{file_name}_presenter_test_rails_5.rb")
          end
        when :rspec
          @rspec_require_file = rspec_helper_filename
          template 'new_presenter_spec.rb', File.join("spec", "presenters", "#{module_name_for_path(module_name)}", "#{file_name}_presenter_spec.rb"), :assigns => { :rspec_require_file => @rspec_require_file }
        else
          say "Unsupported test_framework: #{Versionist.configuration.configured_test_framework}"
        end
      end
    end
  end
end


text:
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.kizitonwose.colorpreferencesample.PreferenceCompatActivity">

    <fragment
        android:name="com.kizitonwose.colorpreferencesample.PreferenceCompatActivity$MyPreferenceFragmentCompat"
        android:tag="PreferenceFragmentCompat"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</FrameLayout>


text:
namespace tensorflow {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_tensorflow_2fcore_2fframework_2ftensor_2eproto();
void protobuf_AssignDesc_tensorflow_2fcore_2fframework_2ftensor_2eproto();
void protobuf_ShutdownFile_tensorflow_2fcore_2fframework_2ftensor_2eproto();

class TensorProto;

// ===================================================================

class TensorProto : public ::google::protobuf::Message {
 public:
  TensorProto();
  virtual ~TensorProto();

  TensorProto(const TensorProto& from);

  inline TensorProto& operator=(const TensorProto& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TensorProto& default_instance();

  void Swap(TensorProto* other);

  // implements Message ----------------------------------------------

  inline TensorProto* New() const { return New(NULL); }

  TensorProto* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TensorProto& from);
  void MergeFrom(const TensorProto& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TensorProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .tensorflow.DataType dtype = 1;
  void clear_dtype();
  static const int kDtypeFieldNumber = 1;
  ::tensorflow::DataType dtype() const;
  void set_dtype(::tensorflow::DataType value);

  // optional .tensorflow.TensorShapeProto tensor_shape = 2;
  bool has_tensor_shape() const;
  void clear_tensor_shape();
  static const int kTensorShapeFieldNumber = 2;
  const ::tensorflow::TensorShapeProto& tensor_shape() const;
  ::tensorflow::TensorShapeProto* mutable_tensor_shape();
  ::tensorflow::TensorShapeProto* release_tensor_shape();
  void set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape);

  // optional int32 version_number = 3;
  void clear_version_number();
  static const int kVersionNumberFieldNumber = 3;
  ::google::protobuf::int32 version_number() const;
  void set_version_number(::google::protobuf::int32 value);

  // optional bytes tensor_content = 4;
  void clear_tensor_content();
  static const int kTensorContentFieldNumber = 4;
  const ::std::string& tensor_content() const;
  void set_tensor_content(const ::std::string& value);
  void set_tensor_content(const char* value);
  void set_tensor_content(const void* value, size_t size);
  ::std::string* mutable_tensor_content();
  ::std::string* release_tensor_content();
  void set_allocated_tensor_content(::std::string* tensor_content);

  // repeated float float_val = 5 [packed = true];
  int float_val_size() const;
  void clear_float_val();
  static const int kFloatValFieldNumber = 5;
  float float_val(int index) const;
  void set_float_val(int index, float value);
  void add_float_val(float value);
  const ::google::protobuf::RepeatedField< float >&
      float_val() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_float_val();

  // repeated double double_val = 6 [packed = true];
  int double_val_size() const;
  void clear_double_val();
  static const int kDoubleValFieldNumber = 6;
  double double_val(int index) const;
  void set_double_val(int index, double value);
  void add_double_val(double value);
  const ::google::protobuf::RepeatedField< double >&
      double_val() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_double_val();

  // repeated int32 int_val = 7 [packed = true];
  int int_val_size() const;
  void clear_int_val();
  static const int kIntValFieldNumber = 7;
  ::google::protobuf::int32 int_val(int index) const;
  void set_int_val(int index, ::google::protobuf::int32 value);
  void add_int_val(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      int_val() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_int_val();

  // repeated bytes string_val = 8;
  int string_val_size() const;
  void clear_string_val();
  static const int kStringValFieldNumber = 8;
  const ::std::string& string_val(int index) const;
  ::std::string* mutable_string_val(int index);
  void set_string_val(int index, const ::std::string& value);
  void set_string_val(int index, const char* value);
  void set_string_val(int index, const void* value, size_t size);
  ::std::string* add_string_val();
  void add_string_val(const ::std::string& value);
  void add_string_val(const char* value);
  void add_string_val(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& string_val() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_val();

  // repeated float scomplex_val = 9 [packed = true];
  int scomplex_val_size() const;
  void clear_scomplex_val();
  static const int kScomplexValFieldNumber = 9;
  float scomplex_val(int index) const;
  void set_scomplex_val(int index, float value);
  void add_scomplex_val(float value);
  const ::google::protobuf::RepeatedField< float >&
      scomplex_val() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_scomplex_val();

  // repeated int64 int64_val = 10 [packed = true];
  int int64_val_size() const;
  void clear_int64_val();
  static const int kInt64ValFieldNumber = 10;
  ::google::protobuf::int64 int64_val(int index) const;
  void set_int64_val(int index, ::google::protobuf::int64 value);
  void add_int64_val(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      int64_val() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_int64_val();

  // repeated bool bool_val = 11 [packed = true];
  int bool_val_size() const;
  void clear_bool_val();
  static const int kBoolValFieldNumber = 11;
  bool bool_val(int index) const;
  void set_bool_val(int index, bool value);
  void add_bool_val(bool value);
  const ::google::protobuf::RepeatedField< bool >&
      bool_val() const;
  ::google::protobuf::RepeatedField< bool >*
      mutable_bool_val();

  // @@protoc_insertion_point(class_scope:tensorflow.TensorProto)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  bool _is_default_instance_;
  ::tensorflow::TensorShapeProto* tensor_shape_;
  int dtype_;
  ::google::protobuf::int32 version_number_;
  ::google::protobuf::internal::ArenaStringPtr tensor_content_;
  ::google::protobuf::RepeatedField< float > float_val_;
  mutable int _float_val_cached_byte_size_;
  ::google::protobuf::RepeatedField< double > double_val_;
  mutable int _double_val_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > int_val_;
  mutable int _int_val_cached_byte_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> string_val_;
  ::google::protobuf::RepeatedField< float > scomplex_val_;
  mutable int _scomplex_val_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > int64_val_;
  mutable int _int64_val_cached_byte_size_;
  ::google::protobuf::RepeatedField< bool > bool_val_;
  mutable int _bool_val_cached_byte_size_;
  mutable int _cached_size_;
  friend void  protobuf_AddDesc_tensorflow_2fcore_2fframework_2ftensor_2eproto();
  friend void protobuf_AssignDesc_tensorflow_2fcore_2fframework_2ftensor_2eproto();
  friend void protobuf_ShutdownFile_tensorflow_2fcore_2fframework_2ftensor_2eproto();

  void InitAsDefaultInstance();
  static TensorProto* default_instance_;
};
// ===================================================================

// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// TensorProto

// optional .tensorflow.DataType dtype = 1;
inline void TensorProto::clear_dtype() {
  dtype_ = 0;
}
inline ::tensorflow::DataType TensorProto::dtype() const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.dtype)
  return static_cast< ::tensorflow::DataType >(dtype_);
}
inline void TensorProto::set_dtype(::tensorflow::DataType value) {

  dtype_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.dtype)
}

// optional .tensorflow.TensorShapeProto tensor_shape = 2;
inline bool TensorProto::has_tensor_shape() const {
  return !_is_default_instance_ && tensor_shape_ != NULL;
}
inline void TensorProto::clear_tensor_shape() {
  if (GetArenaNoVirtual() == NULL && tensor_shape_ != NULL) delete tensor_shape_;
  tensor_shape_ = NULL;
}
inline const ::tensorflow::TensorShapeProto& TensorProto::tensor_shape() const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_shape)
  return tensor_shape_ != NULL ? *tensor_shape_ : *default_instance_->tensor_shape_;
}
inline ::tensorflow::TensorShapeProto* TensorProto::mutable_tensor_shape() {

  if (tensor_shape_ == NULL) {
    tensor_shape_ = new ::tensorflow::TensorShapeProto;
  }
  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_shape)
  return tensor_shape_;
}
inline ::tensorflow::TensorShapeProto* TensorProto::release_tensor_shape() {

  ::tensorflow::TensorShapeProto* temp = tensor_shape_;
  tensor_shape_ = NULL;
  return temp;
}
inline void TensorProto::set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape) {
  delete tensor_shape_;
  tensor_shape_ = tensor_shape;
  if (tensor_shape) {

  } else {

  }
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_shape)
}

// optional int32 version_number = 3;
inline void TensorProto::clear_version_number() {
  version_number_ = 0;
}
inline ::google::protobuf::int32 TensorProto::version_number() const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.version_number)
  return version_number_;
}
inline void TensorProto::set_version_number(::google::protobuf::int32 value) {

  version_number_ = value;
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.version_number)
}

// optional bytes tensor_content = 4;
inline void TensorProto::clear_tensor_content() {
  tensor_content_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& TensorProto::tensor_content() const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_content)
  return tensor_content_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TensorProto::set_tensor_content(const ::std::string& value) {

  tensor_content_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.tensor_content)
}
inline void TensorProto::set_tensor_content(const char* value) {

  tensor_content_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.tensor_content)
}
inline void TensorProto::set_tensor_content(const void* value, size_t size) {

  tensor_content_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.tensor_content)
}
inline ::std::string* TensorProto::mutable_tensor_content() {

  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_content)
  return tensor_content_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TensorProto::release_tensor_content() {

  return tensor_content_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TensorProto::set_allocated_tensor_content(::std::string* tensor_content) {
  if (tensor_content != NULL) {

  } else {

  }
  tensor_content_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tensor_content);
  // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_content)
}

// repeated float float_val = 5 [packed = true];
inline int TensorProto::float_val_size() const {
  return float_val_.size();
}
inline void TensorProto::clear_float_val() {
  float_val_.Clear();
}
inline float TensorProto::float_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.float_val)
  return float_val_.Get(index);
}
inline void TensorProto::set_float_val(int index, float value) {
  float_val_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.float_val)
}
inline void TensorProto::add_float_val(float value) {
  float_val_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.float_val)
}
inline const ::google::protobuf::RepeatedField< float >&
TensorProto::float_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.float_val)
  return float_val_;
}
inline ::google::protobuf::RepeatedField< float >*
TensorProto::mutable_float_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.float_val)
  return &float_val_;
}

// repeated double double_val = 6 [packed = true];
inline int TensorProto::double_val_size() const {
  return double_val_.size();
}
inline void TensorProto::clear_double_val() {
  double_val_.Clear();
}
inline double TensorProto::double_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.double_val)
  return double_val_.Get(index);
}
inline void TensorProto::set_double_val(int index, double value) {
  double_val_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.double_val)
}
inline void TensorProto::add_double_val(double value) {
  double_val_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.double_val)
}
inline const ::google::protobuf::RepeatedField< double >&
TensorProto::double_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.double_val)
  return double_val_;
}
inline ::google::protobuf::RepeatedField< double >*
TensorProto::mutable_double_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.double_val)
  return &double_val_;
}

// repeated int32 int_val = 7 [packed = true];
inline int TensorProto::int_val_size() const {
  return int_val_.size();
}
inline void TensorProto::clear_int_val() {
  int_val_.Clear();
}
inline ::google::protobuf::int32 TensorProto::int_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int_val)
  return int_val_.Get(index);
}
inline void TensorProto::set_int_val(int index, ::google::protobuf::int32 value) {
  int_val_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int_val)
}
inline void TensorProto::add_int_val(::google::protobuf::int32 value) {
  int_val_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int_val)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TensorProto::int_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int_val)
  return int_val_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TensorProto::mutable_int_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int_val)
  return &int_val_;
}

// repeated bytes string_val = 8;
inline int TensorProto::string_val_size() const {
  return string_val_.size();
}
inline void TensorProto::clear_string_val() {
  string_val_.Clear();
}
inline const ::std::string& TensorProto::string_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.string_val)
  return string_val_.Get(index);
}
inline ::std::string* TensorProto::mutable_string_val(int index) {
  // @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.string_val)
  return string_val_.Mutable(index);
}
inline void TensorProto::set_string_val(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.string_val)
  string_val_.Mutable(index)->assign(value);
}
inline void TensorProto::set_string_val(int index, const char* value) {
  string_val_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.string_val)
}
inline void TensorProto::set_string_val(int index, const void* value, size_t size) {
  string_val_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.string_val)
}
inline ::std::string* TensorProto::add_string_val() {
  return string_val_.Add();
}
inline void TensorProto::add_string_val(const ::std::string& value) {
  string_val_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.string_val)
}
inline void TensorProto::add_string_val(const char* value) {
  string_val_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:tensorflow.TensorProto.string_val)
}
inline void TensorProto::add_string_val(const void* value, size_t size) {
  string_val_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:tensorflow.TensorProto.string_val)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TensorProto::string_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.string_val)
  return string_val_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TensorProto::mutable_string_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.string_val)
  return &string_val_;
}

// repeated float scomplex_val = 9 [packed = true];
inline int TensorProto::scomplex_val_size() const {
  return scomplex_val_.size();
}
inline void TensorProto::clear_scomplex_val() {
  scomplex_val_.Clear();
}
inline float TensorProto::scomplex_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.scomplex_val)
  return scomplex_val_.Get(index);
}
inline void TensorProto::set_scomplex_val(int index, float value) {
  scomplex_val_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.scomplex_val)
}
inline void TensorProto::add_scomplex_val(float value) {
  scomplex_val_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.scomplex_val)
}
inline const ::google::protobuf::RepeatedField< float >&
TensorProto::scomplex_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.scomplex_val)
  return scomplex_val_;
}
inline ::google::protobuf::RepeatedField< float >*
TensorProto::mutable_scomplex_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.scomplex_val)
  return &scomplex_val_;
}

// repeated int64 int64_val = 10 [packed = true];
inline int TensorProto::int64_val_size() const {
  return int64_val_.size();
}
inline void TensorProto::clear_int64_val() {
  int64_val_.Clear();
}
inline ::google::protobuf::int64 TensorProto::int64_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.int64_val)
  return int64_val_.Get(index);
}
inline void TensorProto::set_int64_val(int index, ::google::protobuf::int64 value) {
  int64_val_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.int64_val)
}
inline void TensorProto::add_int64_val(::google::protobuf::int64 value) {
  int64_val_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.int64_val)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TensorProto::int64_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.int64_val)
  return int64_val_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TensorProto::mutable_int64_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int64_val)
  return &int64_val_;
}

// repeated bool bool_val = 11 [packed = true];
inline int TensorProto::bool_val_size() const {
  return bool_val_.size();
}
inline void TensorProto::clear_bool_val() {
  bool_val_.Clear();
}
inline bool TensorProto::bool_val(int index) const {
  // @@protoc_insertion_point(field_get:tensorflow.TensorProto.bool_val)
  return bool_val_.Get(index);
}
inline void TensorProto::set_bool_val(int index, bool value) {
  bool_val_.Set(index, value);
  // @@protoc_insertion_point(field_set:tensorflow.TensorProto.bool_val)
}
inline void TensorProto::add_bool_val(bool value) {
  bool_val_.Add(value);
  // @@protoc_insertion_point(field_add:tensorflow.TensorProto.bool_val)
}
inline const ::google::protobuf::RepeatedField< bool >&
TensorProto::bool_val() const {
  // @@protoc_insertion_point(field_list:tensorflow.TensorProto.bool_val)
  return bool_val_;
}
inline ::google::protobuf::RepeatedField< bool >*
TensorProto::mutable_bool_val() {
  // @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.bool_val)
  return &bool_val_;
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace tensorflow

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_tensorflow_2fcore_2fframework_2ftensor_2eproto__INCLUDED


text:
<?php
/**
 * HTML cache invalidation of all pages linking to a given title.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 * @ingroup Cache
 */

/**
 * Job to purge the cache for all pages that link to or use another page or file
 *
 * This job comes in a few variants:
 *   - a) Recursive jobs to purge caches for backlink pages for a given title.
 *        These jobs have have (recursive:true,table:<table>) set.
 *   - b) Jobs to purge caches for a set of titles (the job title is ignored).
 *	      These jobs have have (pages:(<page ID>:(<namespace>,<title>),...) set.
 *
 * @ingroup JobQueue
 */
class HTMLCacheUpdateJob extends Job {
	function __construct( $title, $params = '' ) {
		parent::__construct( 'htmlCacheUpdate', $title, $params );
		// Base backlink purge jobs can be de-duplicated
		$this->removeDuplicates = ( !isset( $params['range'] ) && !isset( $params['pages'] ) );
	}

	function run() {
		global $wgUpdateRowsPerJob, $wgUpdateRowsPerQuery;

		static $expected = array( 'recursive', 'pages' ); // new jobs have one of these

		$oldRangeJob = false;
		if ( !array_intersect( array_keys( $this->params ), $expected ) ) {
			// B/C for older job params formats that lack these fields:
			// a) base jobs with just ("table") and b) range jobs with ("table","start","end")
			if ( isset( $this->params['start'] ) && isset( $this->params['end'] ) ) {
				$oldRangeJob = true;
			} else {
				$this->params['recursive'] = true; // base job
			}
		}

		// Job to purge all (or a range of) backlink pages for a page
		if ( !empty( $this->params['recursive'] ) ) {
			// Convert this into no more than $wgUpdateRowsPerJob HTMLCacheUpdateJob per-title
			// jobs and possibly a recursive HTMLCacheUpdateJob job for the rest of the backlinks
			$jobs = BacklinkJobUtils::partitionBacklinkJob(
				$this,
				$wgUpdateRowsPerJob,
				$wgUpdateRowsPerQuery, // jobs-per-title
				// Carry over information for de-duplication
				array( 'params' => $this->getRootJobParams() )
			);
			JobQueueGroup::singleton()->push( $jobs );
		// Job to purge pages for for a set of titles
		} elseif ( isset( $this->params['pages'] ) ) {
			$this->invalidateTitles( $this->params['pages'] );
		// B/C for job to purge a range of backlink pages for a given page
		} elseif ( $oldRangeJob ) {
			$titleArray = $this->title->getBacklinkCache()->getLinks(
				$this->params['table'], $this->params['start'], $this->params['end'] );

			$pages = array(); // same format BacklinkJobUtils uses
			foreach ( $titleArray as $tl ) {
				$pages[$tl->getArticleId()] = array( $tl->getNamespace(), $tl->getDbKey() );
			}

			$jobs = array();
			foreach ( array_chunk( $pages, $wgUpdateRowsPerJob ) as $pageChunk ) {
				$jobs[] = new HTMLCacheUpdateJob( $this->title,
					array(
						'table' => $this->params['table'],
						'pages' => $pageChunk
					) + $this->getRootJobParams() // carry over information for de-duplication
				);
			}
			JobQueueGroup::singleton()->push( $jobs );
		}

		return true;
	}

	/**
	 * @param array $pages Map of (page ID => (namespace, DB key)) entries
	 */
	protected function invalidateTitles( array $pages ) {
		global $wgUpdateRowsPerQuery, $wgUseFileCache, $wgUseSquid;

		// Get all page IDs in this query into an array
		$pageIds = array_keys( $pages );
		if ( !$pageIds ) {
			return;
		}

		$dbw = wfGetDB( DB_MASTER );

		// The page_touched field will need to be bumped for these pages.
		// Only bump it to the present time if no "rootJobTimestamp" was known.
		// If it is known, it can be used instead, which avoids invalidating output
		// that was in fact generated *after* the relevant dependency change time
		// (e.g. template edit). This is particularily useful since refreshLinks jobs
		// save back parser output and usually run along side htmlCacheUpdate jobs;
		// their saved output would be invalidated by using the current timestamp.
		if ( isset( $this->params['rootJobTimestamp'] ) ) {
			$touchTimestamp = $this->params['rootJobTimestamp'];
		} else {
			$touchTimestamp = wfTimestampNow();
		}

		// Update page_touched (skipping pages already touched since the root job).
		// Check $wgUpdateRowsPerQuery for sanity; batch jobs are sized by that already.
		foreach ( array_chunk( $pageIds, $wgUpdateRowsPerQuery ) as $batch ) {
			$dbw->update( 'page',
				array( 'page_touched' => $dbw->timestamp( $touchTimestamp ) ),
				array( 'page_id' => $batch,
					// don't invalidated pages that were already invalidated
					"page_touched < " . $dbw->addQuotes( $dbw->timestamp( $touchTimestamp ) )
				),
				__METHOD__
			);
		}
		// Get the list of affected pages (races only mean something else did the purge)
		$titleArray = TitleArray::newFromResult( $dbw->select(
			'page',
			array( 'page_namespace', 'page_title' ),
			array( 'page_id' => $pageIds, 'page_touched' => $dbw->timestamp( $touchTimestamp ) ),
			__METHOD__
		) );

		// Update squid
		if ( $wgUseSquid ) {
			$u = SquidUpdate::newFromTitles( $titleArray );
			$u->doUpdate();
		}

		// Update file cache
		if ( $wgUseFileCache ) {
			foreach ( $titleArray as $title ) {
				HTMLFileCache::clearFileCache( $title );
			}
		}
	}

	public function workItemCount() {
		return isset( $this->params['pages'] ) ? count( $this->params['pages'] ) : 1;
	}
}