BitWasp\Bitcoin\Serializer\Types

Complexity

Total Complexity

31

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	factory()	0	9	2
A	bytestring()	0	4	1
A	bytestringle()	0	4	1
A	uint8()	0	4	1
A	uint8le()	0	4	1
A	uint16()	0	4	1
A	uint16le()	0	4	1
A	uint32()	0	4	1
A	uint32le()	0	4	1
A	uint64()	0	4	1
A	uint64le()	0	4	1
A	uint128()	0	4	1
A	uint128le()	0	4	1
A	uint256()	0	4	1
A	uint256le()	0	4	1
A	int8()	0	4	1
A	int8le()	0	4	1
A	int16()	0	4	1
A	int16le()	0	4	1
A	int32()	0	4	1
A	int32le()	0	4	1
A	int64()	0	4	1
A	int64le()	0	4	1
A	int128()	0	4	1
A	int128le()	0	4	1
A	int256()	0	4	1
A	int256le()	0	4	1
A	varint()	0	4	1
A	varstring()	0	4	1
A	vector()	0	4	1

<?php

namespace BitWasp\Bitcoin\Serializer;

use BitWasp\Buffertools\CachingTypeFactory;
use BitWasp\Buffertools\Types\ByteString;
use BitWasp\Buffertools\Types\Int128;
use BitWasp\Buffertools\Types\Int16;
use BitWasp\Buffertools\Types\Int256;
use BitWasp\Buffertools\Types\Int32;
use BitWasp\Buffertools\Types\Int64;
use BitWasp\Buffertools\Types\Int8;
use BitWasp\Buffertools\Types\Uint128;
use BitWasp\Buffertools\Types\Uint16;
use BitWasp\Buffertools\Types\Uint256;
use BitWasp\Buffertools\Types\Uint32;
use BitWasp\Buffertools\Types\Uint64;
use BitWasp\Buffertools\Types\Uint8;
use BitWasp\Buffertools\Types\VarInt;
use BitWasp\Buffertools\Types\VarString;

class Types
{
    /**
     * @return CachingTypeFactory
     */
    public static function factory()
    {
        static $factory;
        if (null === $factory) {
            $factory = new CachingTypeFactory();
        }

        return $factory;
    }

    /**
     * @param int $length
     * @return ByteString
     */
    public static function bytestring($length)
    {
        return static::factory()->{__FUNCTION__}($length);
    }

    /**
     * @param int $length
     * @return ByteString
     */
    public static function bytestringle($length)
    {
        return static::factory()->{__FUNCTION__}($length);
    }

    /**
     * @return Uint8
     */
    public static function uint8()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint8
     */
    public static function uint8le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint16
     */
    public static function uint16()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint16
     */
    public static function uint16le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint32
     */
    public static function uint32()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint32
     */
    public static function uint32le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint64
     */
    public static function uint64()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint64
     */
    public static function uint64le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint128
     */
    public static function uint128()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint128
     */
    public static function uint128le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint256
     */
    public static function uint256()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Uint256
     */
    public static function uint256le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int8
     */
    public static function int8()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int8
     */
    public static function int8le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int16
     */
    public static function int16()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int16
     */
    public static function int16le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int32
     */
    public static function int32()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int32
     */
    public static function int32le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int64
     */
    public static function int64()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int64
     */
    public static function int64le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int128
     */
    public static function int128()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int128
     */
    public static function int128le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int256
     */
    public static function int256()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return Int256
     */
    public static function int256le()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return VarInt
     */
    public static function varint()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @return VarString
     */
    public static function varstring()
    {
        return static::factory()->{__FUNCTION__}();
    }

    /**
     * @param callable $reader
     * @return \BitWasp\Buffertools\Types\Vector
     */
    public static function vector(callable $reader)
    {
        return static::factory()->vector($reader);
    }
}