MutableRevisionRecord.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;
 
use CommentStoreComment;
use Content;
use InvalidArgumentException;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Storage\RevisionSlotsUpdate;
use MediaWiki\User\UserIdentity;
use MWException;
use MWTimestamp;
use Wikimedia\Assert\Assert;
 
class MutableRevisionRecord extends RevisionRecord {
 
    public static function newFromParentRevision( RevisionRecord $parent ) {
        $rev = new MutableRevisionRecord( $parent->getPage(), $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;
    }
 
    public static function newUpdatedRevisionRecord(
        RevisionRecord $revision,
        array $slots
    ): MutableRevisionRecord {
        $newRevisionRecord = new MutableRevisionRecord(
            $revision->getPage(),
            $revision->getWikiId()
        );
 
        $newRevisionRecord->setId( $revision->getId( $revision->getWikiId() ) );
        $newRevisionRecord->setPageId( $revision->getPageId( $revision->getWikiId() ) );
        $newRevisionRecord->setParentId( $revision->getParentId( $revision->getWikiId() ) );
        $newRevisionRecord->setUser( $revision->getUser() );
 
        foreach ( $revision->getSlots()->getSlots() as $role => $slot ) {
            $newRevisionRecord->setSlot( $slot );
        }
 
        foreach ( $slots as $role => $slot ) {
            $newRevisionRecord->setSlot( $slot );
        }
 
        return $newRevisionRecord;
    }
 
    public function __construct( PageIdentity $page, $wikiId = self::LOCAL ) {
        $slots = new MutableRevisionSlots( [], function () {
            $this->resetAggregateValues();
        } );
 
        parent::__construct( $page, $slots, $wikiId );
    }
 
    public function setParentId( $parentId ) {
        Assert::parameterType( 'integer', $parentId, '$parentId' );
 
        $this->mParentId = $parentId;
 
        return $this;
    }
 
    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 );
 
        return $this;
    }
 
    public function inheritSlot( SlotRecord $parentSlot ) {
        $this->mSlots->inheritSlot( $parentSlot );
 
        return $this;
    }
 
    public function setContent( $role, Content $content ) {
        $this->mSlots->setContent( $role, $content );
 
        return $this;
    }
 
    public function removeSlot( $role ) {
        $this->mSlots->removeSlot( $role );
 
        return $this;
    }
 
    public function applyUpdate( RevisionSlotsUpdate $update ) {
        $update->apply( $this->mSlots );
 
        return $this;
    }
 
    public function setComment( CommentStoreComment $comment ) {
        $this->mComment = $comment;
 
        return $this;
    }
 
    public function setSha1( $sha1 ) {
        Assert::parameterType( 'string', $sha1, '$sha1' );
 
        $this->mSha1 = $sha1;
 
        return $this;
    }
 
    public function setSize( $size ) {
        Assert::parameterType( 'integer', $size, '$size' );
 
        $this->mSize = $size;
 
        return $this;
    }
 
    public function setVisibility( $visibility ) {
        Assert::parameterType( 'integer', $visibility, '$visibility' );
 
        $this->mDeleted = $visibility;
 
        return $this;
    }
 
    public function setTimestamp( $timestamp ) {
        Assert::parameterType( 'string', $timestamp, '$timestamp' );
 
        $this->mTimestamp = MWTimestamp::convert( TS_MW, $timestamp );
 
        return $this;
    }
 
    public function setMinorEdit( $minorEdit ) {
        Assert::parameterType( 'boolean', $minorEdit, '$minorEdit' );
 
        $this->mMinorEdit = $minorEdit;
 
        return $this;
    }
 
    public function setId( $id ) {
        Assert::parameterType( 'integer', $id, '$id' );
 
        $this->mId = $id;
 
        return $this;
    }
 
    public function setUser( UserIdentity $user ) {
        $this->mUser = $user;
 
        return $this;
    }
 
    public function setPageId( $pageId ) {
        Assert::parameterType( 'integer', $pageId, '$pageId' );
 
        $pageIdBasedOnPage = $this->getArticleId( $this->mPage );
        if ( $pageIdBasedOnPage && $pageIdBasedOnPage !== $this->getArticleId( $this->mPage ) ) {
            throw new InvalidArgumentException(
                'The given page does not belong to page ID ' . $this->mPageId
            );
        }
 
        $this->mPageId = $pageId;
 
        return $this;
    }
 
    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' );