RevisionSlots.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Revision;
 
use Content;
use Wikimedia\Assert\Assert;
use Wikimedia\NonSerializable\NonSerializableTrait;
 
class RevisionSlots {
    use NonSerializableTrait;
 
    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 ): void {
        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 getContent( $role ): Content {
        // Return a copy to be safe. Immutable content objects return $this from copy().
        return $this->getSlot( $role )->getContent()->copy();
    }
 
    public function getSlot( $role ): SlotRecord {
        $slots = $this->getSlots();
 
        if ( isset( $slots[$role] ) ) {
            return $slots[$role];
        } else {
            throw new RevisionAccessException(
                'No such slot: {role}',
                [ 'role' => $role ]
            );
        }
    }
 
    public function hasSlot( $role ): bool {
        $slots = $this->getSlots();
 
        return isset( $slots[$role] );
    }
 
    public function getSlotRoles(): array {
        $slots = $this->getSlots();
        return array_keys( $slots );
    }
 
    public function computeSize(): int {
        return array_reduce( $this->getPrimarySlots(), static function ( $accu, SlotRecord $slot ) {
            return $accu + $slot->getSize();
        }, 0 );
    }
 
    public function getSlots(): array {
        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(): string {
        $slots = $this->getPrimarySlots();
        ksort( $slots );
 
        if ( !$slots ) {
            return SlotRecord::base36Sha1( '' );
        }
 
        return array_reduce( $slots, static function ( $accu, SlotRecord $slot ) {
            return $accu === null
                ? $slot->getSha1()
                : SlotRecord::base36Sha1( $accu . $slot->getSha1() );
        }, null );
    }
 
    public function getOriginalSlots(): array {
        return array_filter(
            $this->getSlots(),
            static function ( SlotRecord $slot ) {
                return !$slot->isInherited();
            }
        );
    }
 
    public function getInheritedSlots(): array {
        return array_filter(
            $this->getSlots(),
            static function ( SlotRecord $slot ) {
                return $slot->isInherited();
            }
        );
    }
 
    public function getPrimarySlots(): array {
        return array_filter(
            $this->getSlots(),
            static function ( SlotRecord $slot ) {
                return !$slot->isDerived();
            }
        );
    }
 
    public function hasSameContent( RevisionSlots $other ): bool {
        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 ): array {
        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;
    }
 
}