CompoundTag.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\NbtStreamReader;
use pocketmine\nbt\NbtStreamWriter;
use pocketmine\nbt\NoSuchTagException;
use pocketmine\nbt\ReaderTracker;
use pocketmine\nbt\UnexpectedTagTypeException;
use pocketmine\utils\Limits;
use function count;
use function func_num_args;
use function get_class;
use function is_int;
use function sprintf;
use function str_repeat;
use function strlen;
use function strval;
 
final class CompoundTag extends Tag implements \Countable, \IteratorAggregate{
    use NoDynamicFieldsTrait;
 
    private $value = [];
 
    public function __construct(){
        self::restrictArgCount(__METHOD__, func_num_args(), 0);
    }
 
    public static function create() : self{
        return new self;
    }
 
    public function count() : int{
        return count($this->value);
    }
 
    public function getCount(){
        return count($this->value);
    }
 
    public function getValue(){
        return $this->value;
    }
 
    /*
     * Here follows many functions of misery for the sake of type safety. We really needs generics in PHP :(
     */
 
    public function getTag(string $name) : ?Tag{
        return $this->value[$name] ?? null;
    }
 
    public function getListTag(string $name, string $tagClass = Tag::class) : ?ListTag{
        $tag = $this->getTag($name);
        if($tag !== null){
            if(!$tag instanceof ListTag){
                throw new UnexpectedTagTypeException("Expected a tag of type " . ListTag::class . ", got " . get_class($tag));
            }
            $casted = $tag->cast($tagClass);
            if($casted === null){
                throw new UnexpectedTagTypeException("Unable to cast list to ListTag<$tagClass>");
            }
            return $casted;
        }
        return null;
    }
 
    public function getCompoundTag(string $name) : ?CompoundTag{
        $tag = $this->getTag($name);
        if($tag !== null && !($tag instanceof CompoundTag)){
            throw new UnexpectedTagTypeException("Expected a tag of type " . CompoundTag::class . ", got " . get_class($tag));
        }
        return $tag;
    }
 
    public function setTag(string $name, Tag $tag) : self{
        if(strlen($name) > Limits::INT16_MAX){
            throw new \InvalidArgumentException(sprintf("Tag name must be at most %d bytes, but got %d bytes", Limits::INT16_MAX, strlen($name)));
        }
        $this->value[$name] = $tag;
        return $this;
    }
 
    public function removeTag(string ...$names) : void{
        foreach($names as $name){
            unset($this->value[$name]);
        }
    }
 
    private function getTagValue(string $name, string $expectedClass, $default = null){
        $tag = $this->getTag($name);
        if($tag instanceof $expectedClass){
            return $tag->getValue();
        }
        if($tag !== null){
            throw new UnexpectedTagTypeException("Expected a tag of type $expectedClass, got " . get_class($tag));
        }
 
        if($default === null){
            throw new NoSuchTagException("Tag \"$name\" does not exist");
        }
 
        return $default;
    }
 
    /*
     * The following methods are wrappers around getTagValue() with type safety.
     */
 
    public function getByte(string $name, ?int $default = null) : int{
        return $this->getTagValue($name, ByteTag::class, $default);
    }
 
    public function getShort(string $name, ?int $default = null) : int{
        return $this->getTagValue($name, ShortTag::class, $default);
    }
 
    public function getInt(string $name, ?int $default = null) : int{
        return $this->getTagValue($name, IntTag::class, $default);
    }
 
    public function getLong(string $name, ?int $default = null) : int{
        return $this->getTagValue($name, LongTag::class, $default);
    }
 
    public function getFloat(string $name, ?float $default = null) : float{
        return $this->getTagValue($name, FloatTag::class, $default);
    }
 
    public function getDouble(string $name, ?float $default = null) : float{
        return $this->getTagValue($name, DoubleTag::class, $default);
    }
 
    public function getByteArray(string $name, ?string $default = null) : string{
        return $this->getTagValue($name, ByteArrayTag::class, $default);
    }
 
    public function getString(string $name, ?string $default = null) : string{
        return $this->getTagValue($name, StringTag::class, $default);
    }
 
    public function getIntArray(string $name, ?array $default = null) : array{
        return $this->getTagValue($name, IntArrayTag::class, $default);
    }
 
    /*
     * The following methods are wrappers around setTag() which create appropriate tag objects on the fly.
     */
 
    public function setByte(string $name, int $value) : self{
        return $this->setTag($name, new ByteTag($value));
    }
 
    public function setShort(string $name, int $value) : self{
        return $this->setTag($name, new ShortTag($value));
    }
 
    public function setInt(string $name, int $value) : self{
        return $this->setTag($name, new IntTag($value));
    }
 
    public function setLong(string $name, int $value) : self{
        return $this->setTag($name, new LongTag($value));
    }
 
    public function setFloat(string $name, float $value) : self{
        return $this->setTag($name, new FloatTag($value));
    }
 
    public function setDouble(string $name, float $value) : self{
        return $this->setTag($name, new DoubleTag($value));
    }
 
    public function setByteArray(string $name, string $value) : self{
        return $this->setTag($name, new ByteArrayTag($value));
    }
 
    public function setString(string $name, string $value) : self{
        return $this->setTag($name, new StringTag($value));
    }
 
    public function setIntArray(string $name, array $value) : self{
        return $this->setTag($name, new IntArrayTag($value));
    }
 
    protected function getTypeName() : string{
        return "Compound";
    }
 
    public function getType() : int{
        return NBT::TAG_Compound;
    }
 
    public static function read(NbtStreamReader $reader, ReaderTracker $tracker) : self{
        $result = new self;
        $tracker->protectDepth(static function() use($reader, $tracker, $result) : void{
            for($type = $reader->readByte(); $type !== NBT::TAG_End; $type = $reader->readByte()){
                $name = $reader->readString();
                $tag = NBT::createTag($type, $reader, $tracker);
                if($result->getTag($name) !== null){
                    //this is technically a corruption case, but it's very common on older PM worlds (pretty much every
                    //furnace in PM worlds prior to 2017 is affected), and since we can't extricate this borked data
                    //from the rest in Anvil/McRegion worlds, we can't barf on this - it would result in complete loss
                    //of the chunk.
                    //TODO: add a flag to enable throwing on this (strict mode)
                    continue;
                }
                $result->setTag($name, $tag);
            }
        });
        return $result;
    }
 
    public function write(NbtStreamWriter $writer) : void{
        foreach($this->value as $name => $tag){
            if(is_int($name)){
                //PHP sucks
                //we only cast on seeing an int, because forcibly casting other types might conceal bugs.
                $name = (string) $name;
            }
            $writer->writeByte($tag->getType());
            $writer->writeString($name);
            $tag->write($writer);
        }
        $writer->writeByte(NBT::TAG_End);
    }
 
    protected function stringifyValue(int $indentation) : string{
        $str = "{\n";
        foreach($this->value as $name => $tag){
            $str .= str_repeat("  ", $indentation + 1) . "\"$name\" => " . $tag->toString($indentation + 1) . "\n";
        }
        return $str . str_repeat("  ", $indentation) . "}";
    }
 
    public function __clone(){
        foreach($this->value as $key => $tag){
            $this->value[$key] = $tag->safeClone();
        }
    }
 
    protected function makeCopy(){
        return clone $this;
    }
 
    public function getIterator() : \Generator{
        foreach($this->value as $name => $tag){
            // PHP arrays are idiotic and cast keys like "1" to int(1)
            // this also stops us using "yield from". REEEEEEEEEE
            yield strval($name) => $tag;
        }
    }
 
    public function equals(Tag $that) : bool{
        if(!($that instanceof $this) or count($this->value) !== count($that->value)){
            return false;
        }
 
        foreach($this->value as $k => $v){
            $other = $that->value[$k] ?? null;
            if($other === null or !$v->equals($other)){
                return false;
            }
        }
 
        return true;
    }
 
    public function merge(CompoundTag $other) : CompoundTag{
        $new = clone $this;
 
        foreach($other as $k => $namedTag){
            $new->setTag($k, clone $namedTag);
        }
 
        return $new;
    }
}