MutableRevisionRecord.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;

use CommentStoreComment;
use Content;
use InvalidArgumentException;
use MediaWiki\Storage\RevisionSlotsUpdate;
use MediaWiki\User\UserIdentity;
use MWException;
use Title;
use Wikimedia\Assert\Assert;

class MutableRevisionRecord extends RevisionRecord {

    public static function newFromParentRevision( RevisionRecord $parent ) {
        // TODO: ideally, we wouldn't need a Title here
        $title = Title::newFromLinkTarget( $parent->getPageAsLinkTarget() );
        $rev = new MutableRevisionRecord( $title, $parent->getWikiId() );

        foreach ( $parent->getSlotRoles() as $role ) {
            $slot = $parent->getSlot( $role, self::RAW );
            $rev->inheritSlot( $slot );
        }

        $rev->setPageId( $parent->getPageId() );
        $rev->setParentId( $parent->getId() );

        return $rev;
    }

    function __construct( Title $title, $dbDomain = false ) {
        $slots = new MutableRevisionSlots();

        parent::__construct( $title, $slots, $dbDomain );
    }

    public function setParentId( $parentId ) {
        Assert::parameterType( 'integer', $parentId, '$parentId' );

        $this->mParentId = $parentId;
    }

    public function setSlot( SlotRecord $slot ) {
        if ( $slot->hasRevision() && $slot->getRevision() !== $this->getId() ) {
            throw new InvalidArgumentException(
                'The given slot must be an unsaved, unattached one. '
                . 'This slot is already attached to revision ' . $slot->getRevision() . '. '
                . 'Use inheritSlot() instead to preserve a slot from a previous revision.'
            );
        }

        $this->mSlots->setSlot( $slot );
        $this->resetAggregateValues();
    }

    public function inheritSlot( SlotRecord $parentSlot ) {
        $this->mSlots->inheritSlot( $parentSlot );
        $this->resetAggregateValues();
    }

    public function setContent( $role, Content $content ) {
        $this->mSlots->setContent( $role, $content );
        $this->resetAggregateValues();
    }

    public function removeSlot( $role ) {
        $this->mSlots->removeSlot( $role );
        $this->resetAggregateValues();
    }

    public function applyUpdate( RevisionSlotsUpdate $update ) {
        $update->apply( $this->mSlots );
    }

    public function setComment( CommentStoreComment $comment ) {
        $this->mComment = $comment;
    }

    public function setSha1( $sha1 ) {
        Assert::parameterType( 'string', $sha1, '$sha1' );

        $this->mSha1 = $sha1;
    }

    public function setSize( $size ) {
        Assert::parameterType( 'integer', $size, '$size' );

        $this->mSize = $size;
    }

    public function setVisibility( $visibility ) {
        Assert::parameterType( 'integer', $visibility, '$visibility' );

        $this->mDeleted = $visibility;
    }

    public function setTimestamp( $timestamp ) {
        Assert::parameterType( 'string', $timestamp, '$timestamp' );

        $this->mTimestamp = wfTimestamp( TS_MW, $timestamp );
    }

    public function setMinorEdit( $minorEdit ) {
        Assert::parameterType( 'boolean', $minorEdit, '$minorEdit' );

        $this->mMinorEdit = $minorEdit;
    }

    public function setId( $id ) {
        Assert::parameterType( 'integer', $id, '$id' );

        $this->mId = $id;
    }

    public function setUser( UserIdentity $user ) {
        $this->mUser = $user;
    }

    public function setPageId( $pageId ) {
        Assert::parameterType( 'integer', $pageId, '$pageId' );

        if ( $this->mTitle->exists() && $pageId !== $this->mTitle->getArticleID() ) {
            throw new InvalidArgumentException(
                'The given Title does not belong to page ID ' . $this->mPageId
            );
        }

        $this->mPageId = $pageId;
    }

    public function getSize() {
        // If not known, re-calculate and remember. Will be reset when slots change.
        if ( $this->mSize === null ) {
            $this->mSize = $this->mSlots->computeSize();
        }

        return $this->mSize;
    }

    public function getSha1() {
        // If not known, re-calculate and remember. Will be reset when slots change.
        if ( $this->mSha1 === null ) {
            $this->mSha1 = $this->mSlots->computeSha1();
        }

        return $this->mSha1;
    }

    public function getSlots() {
        // Overwritten just guarantee the more narrow return type.
        return parent::getSlots();
    }

    private function resetAggregateValues() {
        $this->mSize = null;
        $this->mSha1 = null;
    }

}

class_alias( MutableRevisionRecord::class, 'MediaWiki\Storage\MutableRevisionRecord' );