RevisionSlots.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;

use Content;
use LogicException;
use Wikimedia\Assert\Assert;

class RevisionSlots {

    protected $slots;

    public function __construct( $slots ) {
        Assert::parameterType( 'array|callable', $slots, '$slots' );

        if ( is_callable( $slots ) ) {
            $this->slots = $slots;
        } else {
            $this->setSlotsInternal( $slots );
        }
    }

    private function setSlotsInternal( array $slots ) {
        Assert::parameterElementType( SlotRecord::class, $slots, '$slots' );

        $this->slots = [];

        // re-key the slot array
        foreach ( $slots as $slot ) {
            $role = $slot->getRole();
            $this->slots[$role] = $slot;
        }
    }

    public function __sleep() {
        throw new LogicException( __CLASS__ . ' is not serializable.' );
    }

    public function getContent( $role ) {
        // Return a copy to be safe. Immutable content objects return $this from copy().
        return $this->getSlot( $role )->getContent()->copy();
    }

    public function getSlot( $role ) {
        $slots = $this->getSlots();

        if ( isset( $slots[$role] ) ) {
            return $slots[$role];
        } else {
            throw new RevisionAccessException( 'No such slot: ' . $role );
        }
    }

    public function hasSlot( $role ) {
        $slots = $this->getSlots();

        return isset( $slots[$role] );
    }

    public function getSlotRoles() {
        $slots = $this->getSlots();
        return array_keys( $slots );
    }

    public function computeSize() {
        return array_reduce( $this->getSlots(), function ( $accu, SlotRecord $slot ) {
            return $accu + $slot->getSize();
        }, 0 );
    }

    public function getSlots() {
        if ( is_callable( $this->slots ) ) {
            $slots = call_user_func( $this->slots );

            Assert::postcondition(
                is_array( $slots ),
                'Slots info callback should return an array of objects'
            );

            $this->setSlotsInternal( $slots );
        }

        return $this->slots;
    }

    public function computeSha1() {
        $slots = $this->getSlots();
        ksort( $slots );

        if ( empty( $slots ) ) {
            return SlotRecord::base36Sha1( '' );
        }

        return array_reduce( $slots, function ( $accu, SlotRecord $slot ) {
            return $accu === null
                ? $slot->getSha1()
                : SlotRecord::base36Sha1( $accu . $slot->getSha1() );
        }, null );
    }

    public function getOriginalSlots() {
        return array_filter(
            $this->getSlots(),
            function ( SlotRecord $slot ) {
                return !$slot->isInherited();
            }
        );
    }

    public function getInheritedSlots() {
        return array_filter(
            $this->getSlots(),
            function ( SlotRecord $slot ) {
                return $slot->isInherited();
            }
        );
    }

    public function hasSameContent( RevisionSlots $other ) {
        if ( $other === $this ) {
            return true;
        }

        $aSlots = $this->getSlots();
        $bSlots = $other->getSlots();

        ksort( $aSlots );
        ksort( $bSlots );

        if ( array_keys( $aSlots ) !== array_keys( $bSlots ) ) {
            return false;
        }

        foreach ( $aSlots as $role => $s ) {
            $t = $bSlots[$role];

            if ( !$s->hasSameContent( $t ) ) {
                return false;
            }
        }

        return true;
    }

    public function getRolesWithDifferentContent( RevisionSlots $other ) {
        if ( $other === $this ) {
            return [];
        }

        $aSlots = $this->getSlots();
        $bSlots = $other->getSlots();

        ksort( $aSlots );
        ksort( $bSlots );

        $different = array_keys( array_merge(
            array_diff_key( $aSlots, $bSlots ),
            array_diff_key( $bSlots, $aSlots )
        ) );

        $common = array_intersect_key( $aSlots, $bSlots );

        foreach ( $common as $role => $s ) {
            $t = $bSlots[$role];

            if ( !$s->hasSameContent( $t ) ) {
                $different[] = $role;
            }
        }

        return $different;
    }

}

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