MutableRevisionRecord.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use CommentStoreComment;
use Content;
use InvalidArgumentException;
use MediaWiki\User\UserIdentity;
use MWException;
use Title;
use Wikimedia\Assert\Assert;
 
class MutableRevisionRecord extends RevisionRecord {
 
    public static function newFromParentRevision(
        RevisionRecord $parent,
        CommentStoreComment $comment,
        UserIdentity $user,
        $timestamp
    ) {
        // TODO: ideally, we wouldn't need a Title here
        $title = Title::newFromLinkTarget( $parent->getPageAsLinkTarget() );
        $rev = new MutableRevisionRecord( $title, $parent->getWikiId() );
 
        $rev->setComment( $comment );
        $rev->setUser( $user );
        $rev->setTimestamp( $timestamp );
 
        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, $wikiId = false ) {
        $slots = new MutableRevisionSlots();
 
        parent::__construct( $title, $slots, $wikiId );
 
        $this->mSlots = $slots; // redundant, but nice for static analysis
    }
 
    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 ) {
        $slot = SlotRecord::newInherited( $parentSlot );
        $this->setSlot( $slot );
    }
 
    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 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;
    }
 
    private function resetAggregateValues() {
        $this->mSize = null;
        $this->mSha1 = null;
    }
 
}