ListTag.php

<?php
 
/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
*/
 
declare(strict_types=1);
 
namespace pocketmine\nbt\tag;
 
use pocketmine\nbt\NBT;
use pocketmine\nbt\NbtDataException;
use pocketmine\nbt\NbtStreamReader;
use pocketmine\nbt\NbtStreamWriter;
use pocketmine\nbt\ReaderTracker;
use function func_num_args;
use function get_class;
use function iterator_to_array;
use function str_repeat;
 
final class ListTag extends Tag implements \Countable, \IteratorAggregate{
    use NoDynamicFieldsTrait;
 
    private $tagType;
    private $value;
 
    public function __construct(array $value = [], int $tagType = NBT::TAG_End){
        self::restrictArgCount(__METHOD__, func_num_args(), 2);
        $this->tagType = $tagType;
        $this->value = new \SplDoublyLinkedList();
        foreach($value as $tag){
            $this->push($tag);
        }
    }
 
    public function getValue() : array{
        $value = [];
        foreach($this->value as $k => $v){
            $value[$k] = $v;
        }
 
        return $value;
    }
 
    public function getAllValues() : array{
        $result = [];
        foreach($this->value as $tag){
            $result[] = $tag->getValue();
        }
 
        return $result;
    }
 
    public function count() : int{
        return $this->value->count();
    }
 
    public function getCount() : int{
        return $this->value->count();
    }
 
    public function push(Tag $tag) : void{
        $this->checkTagType($tag);
        $this->value->push($tag);
    }
 
    public function pop() : Tag{
        return $this->value->pop();
    }
 
    public function unshift(Tag $tag) : void{
        $this->checkTagType($tag);
        $this->value->unshift($tag);
    }
 
    public function shift() : Tag{
        return $this->value->shift();
    }
 
    public function insert(int $offset, Tag $tag){
        $this->checkTagType($tag);
        $this->value->add($offset, $tag);
    }
 
    public function remove(int $offset) : void{
        unset($this->value[$offset]);
    }
 
    public function get(int $offset) : Tag{
        if(!isset($this->value[$offset])){
            throw new \OutOfRangeException("No such tag at offset $offset");
        }
        return $this->value[$offset];
    }
 
    public function first() : Tag{
        return $this->value->bottom();
    }
 
    public function last() : Tag{
        return $this->value->top();
    }
 
    public function set(int $offset, Tag $tag) : void{
        $this->checkTagType($tag);
        $this->value[$offset] = $tag;
    }
 
    public function isset(int $offset) : bool{
        return isset($this->value[$offset]);
    }
 
    public function empty() : bool{
        return $this->value->isEmpty();
    }
 
    protected function getTypeName() : string{
        return "List";
    }
 
    public function getType() : int{
        return NBT::TAG_List;
    }
 
    public function getTagType() : int{
        return $this->tagType;
    }
 
    public function setTagType(int $type){
        if(!$this->value->isEmpty()){
            throw new \LogicException("Cannot change tag type of non-empty ListTag");
        }
        $this->tagType = $type;
    }
 
    private function checkTagType(Tag $tag) : void{
        $type = $tag->getType();
        if($type !== $this->tagType){
            if($this->tagType === NBT::TAG_End){
                $this->tagType = $type;
            }else{
                //TODO: reintroduce type info
                throw new \TypeError("Invalid tag of type " . get_class($tag) . " assigned to ListTag");
            }
        }
    }
 
    public static function read(NbtStreamReader $reader, ReaderTracker $tracker) : self{
        $value = [];
        $tagType = $reader->readByte();
        $size = $reader->readInt();
 
        if($size > 0){
            if($tagType === NBT::TAG_End){
                throw new NbtDataException("Unexpected non-empty list of TAG_End");
            }
 
            $tracker->protectDepth(static function() use($size, $tagType, $reader, $tracker, &$value) : void{
                for($i = 0; $i < $size; ++$i){
                    $value[] = NBT::createTag($tagType, $reader, $tracker);
                }
            });
        }else{
            $tagType = NBT::TAG_End; //Some older NBT implementations used TAG_Byte for empty lists.
        }
        return new self($value, $tagType);
    }
 
    public function write(NbtStreamWriter $writer) : void{
        $writer->writeByte($this->tagType);
        $writer->writeInt($this->value->count());
        foreach($this->value as $tag){
            $tag->write($writer);
        }
    }
 
    protected function stringifyValue(int $indentation) : string{
        $str = "{\n";
        foreach($this->value as $tag){
            $str .= str_repeat("  ", $indentation + 1) . $tag->toString($indentation + 1) . "\n";
        }
        return $str . str_repeat("  ", $indentation) . "}";
    }
 
    public function __clone(){
        $new = new \SplDoublyLinkedList();
 
        foreach($this->value as $tag){
            $new->push($tag->safeClone());
        }
 
        $this->value = $new;
    }
 
    protected function makeCopy(){
        return clone $this;
    }
 
    public function getIterator() : \Generator{
        //we technically don't need iterator_to_array() here, but I don't feel comfortable relying on "yield from" to
        //copy the underlying dataset referenced by SplDoublyLinkedList
        yield from iterator_to_array($this->value, true);
    }
 
    public function equals(Tag $that) : bool{
        if(!($that instanceof $this) or $this->count() !== $that->count()){
            return false;
        }
 
        foreach($this as $k => $v){
            if(!$v->equals($that->get($k))){
                return false;
            }
        }
 
        return true;
    }
}