<?php

namespace SmartData\Utility;

trait Pack
{
    public function uInt8($field) { return pack('C', $field); }
    public function int8($field) { return pack('c', $field); }
    public function uChar($field) { return uInt8($field); }
    public function char($field) { return int8($field); }

    public function uInt16($field) { return pack("v", $field); }
    public function int16($field) { return self::uInt16($field); }

    public function uInt32($field) { return pack("V", $field); }
    public function int32($field) { return self::uInt32($field); }

    public function uInt64($field) { return pack("P", $field); }
    public function int64($field) { return self::uInt64($field); }

    public function f32($field) { return pack('g', $field); }
    public function d64($field) { return pack('e', $field); }

    public function string($field) { return self::uInt8(strlen($field)) . $field; }
}

trait Unpack
{
    public function uInt8(& $bin, $cut=false)
    {
        $uInt8  = substr($bin, 0, 1);
        if($cut)
            $bin = substr($bin, 1);
        return unpack('C', $uInt8)[1];
    }

    public function int8(& $bin, $cut=false)
    {
        $int8 = self::uInt8($bin, $cut);
        return ($int8>0x7F) ? ($int8 - 0x100) : $int8;
    }

    public function uChar(& $bin, $cut=false) { return self::uInt8($bin, $cut); }
    public function char(& $bin, $cut=false) { return self::int8($bin, $cut); }

    public function uInt16(& $bin, $cut=false)
    {
        $uInt16  = substr($bin, 0, 2);
        if($cut)
            $bin = substr($bin, 2);
        return unpack('v', $uInt16)[1];
    }

    public function int16(& $bin, $cut=false)
    {
        $int16 = self::uInt16($bin, $cut);
        return ($int16>0x7FFF) ? ($int16 - 0x10000) : $int16;
    }

    public function uInt32(& $bin, $cut=false)
    {
        $uInt32  = substr($bin, 0, 4);
        if($cut)
            $bin = substr($bin, 4);
        return unpack('V', $uInt32)[1];
    }

    public function int32(& $bin, $cut=false)
    {
        $int32 = self::uInt32($bin, $cut);
        return ($int32>0x7fffffff) ? ($int32 - 0x100000000) : $int32;
    }

    public function uInt64(& $bin, $cut=false)
    {
        $uInt64  = substr($bin, 0, 8);
        if($cut)
            $bin = substr($bin, 8);
        return unpack('P', $uInt64)[1];
    }

    public function int64(& $bin, $cut=false)
    {
        $int64 = self::uInt64($bin, $cut);
        return $int64;
    }

    public function f32(& $bin, $cut=false)
    {
        $f32  = substr($bin, 0, 4);
        if($cut)
            $bin = substr($bin, 4);
        return unpack('g', $f32)[1];
    }

    public function d64(& $bin, $cut=false)
    {
        $d64  = substr($bin, 0, 8);
        if($cut)
            $bin = substr($bin, 8);
        return unpack('e', $d64)[1];
    }

    public function string(& $bin, $cut=false)
    {
        $size = self::uInt8($bin);
        $string = substr($bin, 1, $size);
        if($cut)
            $bin = substr($bin, $size+1);
        return $string;
    }
}