Tdn\PhpTypes\Type\Traits\Transmutable

Complexity

Total Complexity

17

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

73.52%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	toStringType()	0	4	1
A	toBoolType()	0	4	1
A	toIntType()	0	4	1
A	toFloatType()	0	4	1
A	toCollection()	0	4	1
A	toBool()	0	8	2
A	toInt()	0	8	2
A	toFloat()	0	8	2
A	toString()	0	8	2
A	toArray()	0	8	2
A	createInvalidTransformationException()	0	4	1
A	__toString()	0	4	1

<?php

namespace Tdn\PhpTypes\Type\Traits;

use Tdn\PhpTypes\Exception\InvalidTypeCastException;
use Tdn\PhpTypes\Type\Collection;
use Tdn\PhpTypes\Type\StringType;
use Tdn\PhpTypes\Type\BooleanType;
use Tdn\PhpTypes\Type\IntType;
use Tdn\PhpTypes\Type\FloatType;
use Tdn\PhpTypes\Type\Type;
use Tdn\PhpTypes\Type\TransmutableTypeInterface;

/**
 * Trait Transmutable.
 */
trait Transmutable
{
    /**
     * @return StringType
     */
    public function toStringType(): StringType
    {
        return StringType::valueOf($this);
    }

    /**
     * @return BooleanType
     */
    public function toBoolType(): BooleanType
    {
        return BooleanType::valueOf($this);
    }

    /**
     * @return IntType
     */
    public function toIntType(): IntType
    {
        return IntType::valueOf($this);
    }

    /**
     * @return FloatType
     */
    public function toFloatType(): FloatType
    {
        return FloatType::valueOf($this);
    }

    /**
     * @return Collection
     */
    public function toCollection(): Collection
    {
        return Collection::valueOf($this);
    }

    /**
     * @return bool
     */
    public function toBool(): bool
    {
        if ($this instanceof TransmutableTypeInterface) {
            return $this(Type::BOOL);
        }

        throw $this->createInvalidTransformationException('bool');
    }

    /**
     * @return int
     */
    public function toInt(): int
    {
        if ($this instanceof TransmutableTypeInterface) {
            return $this(Type::INT);
        }

        throw $this->createInvalidTransformationException('int');
    }

    /**
     * @return float
     */
    public function toFloat(): float
    {
        if ($this instanceof TransmutableTypeInterface) {
            return $this(Type::FLOAT);
        }

        throw $this->createInvalidTransformationException('float');
    }

    /**
     * @return string
     */
    public function toString(): string
    {
        if ($this instanceof TransmutableTypeInterface) {
            return $this(Type::STRING);
        }

        throw $this->createInvalidTransformationException('string');
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        if ($this instanceof TransmutableTypeInterface) {
            return $this(Type::ARRAY);
        }

        throw $this->createInvalidTransformationException('array');
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->toString();
    }

    private function createInvalidTransformationException($type)
    {
        return new InvalidTypeCastException(static::class, $type);
    }
}