Binary Class Reference

Static Public Member Functions
static	readTriad ($str)
static	writeTriad ($value)
static	readLTriad ($str)
static	writeLTriad ($value)
static	readBool ($b)
static	writeBool ($b)
static	readByte ($c, $signed=true)
static	writeByte ($c)
static	readShort ($str)
static	readSignedShort ($str)
static	writeShort ($value)
static	readLShort ($str, $signed=true)
static	writeLShort ($value)
static	readInt ($str)
static	writeInt ($value)
static	readLInt ($str)
static	writeLInt ($value)
static	readFloat ($str)
static	writeFloat ($value)
static	readLFloat ($str)
static	writeLFloat ($value)
static	readDouble ($str)
static	writeDouble ($value)
static	readLDouble ($str)
static	writeLDouble ($value)
static	readLong ($x)
static	writeLong ($value)
static	readLLong ($str)
static	writeLLong ($value)

Data Fields
const	BIG_ENDIAN = 0x00
const	LITTLE_ENDIAN = 0x01

Member Function Documentation

readBool()

static readBool (   $b )

static

Reads a byte boolean

Parameters

$b

Returns

bool

                                       {
        return self::readByte($b, false) === 0 ? false : true;
    }

readByte()

static readByte (   $c,   $signed = true  )

static

Reads an unsigned/signed byte

Parameters

string	$c
bool	$signed

Returns

int

                                                       {
        $b = ord($c{0});

        if($signed){
            if(PHP_INT_SIZE === 8){
                return $b << 56 >> 56;
            }else{
                return $b << 24 >> 24;
            }
        }else{
            return $b;
        }
    }

readDouble()

static readDouble (   $str )

static

                                           {
        return ENDIANNESS === self::BIG_ENDIAN ? unpack("d", $str)[1] : unpack("d", strrev($str))[1];
    }

readFloat()

static readFloat (   $str )

static

                                          {
        return ENDIANNESS === self::BIG_ENDIAN ? unpack("f", $str)[1] : unpack("f", strrev($str))[1];
    }

readInt()

static readInt (   $str )

static

                                        {
        if(PHP_INT_SIZE === 8){
            return unpack("N", $str)[1] << 32 >> 32;
        }else{
            return unpack("N", $str)[1];
        }
    }

readLDouble()

static readLDouble (   $str )

static

                                            {
        return ENDIANNESS === self::BIG_ENDIAN ? unpack("d", strrev($str))[1] : unpack("d", $str)[1];
    }

readLFloat()

static readLFloat (   $str )

static

                                           {
        return ENDIANNESS === self::BIG_ENDIAN ? unpack("f", strrev($str))[1] : unpack("f", $str)[1];
    }

readLInt()

static readLInt (   $str )

static

                                         {
        if(PHP_INT_SIZE === 8){
            return unpack("V", $str)[1] << 32 >> 32;
        }else{
            return unpack("V", $str)[1];
        }
    }

readLLong()

static readLLong (   $str )

static

                                          {
        return self::readLong(strrev($str));
    }

readLong()

static readLong (   $x )

static

                                       {
        if(PHP_INT_SIZE === 8){
            list(, $int1, $int2) = unpack("N*", $x);

            return ($int1 << 32) | $int2;
        }else{
            $value = "0";
            for($i = 0; $i < 8; $i += 2){
                $value = bcmul($value, "65536", 0);
                $value = bcadd($value, self::readShort(substr($x, $i, 2)), 0);
            }

            if(bccomp($value, "9223372036854775807") == 1){
                $value = bcadd($value, "-18446744073709551616");
            }

            return $value;
        }
    }

readLShort()

static readLShort (   $str,   $signed = true  )

static

Reads a 16-bit signed/unsigned little-endian number

Parameters

	$str
bool	$signed

Returns

int

                                                           {
        $unpacked = unpack("v", $str)[1];

        if($signed){
            if(PHP_INT_SIZE === 8){
                return $unpacked << 48 >> 48;
            }else{
                return $unpacked << 16 >> 16;
            }
        }else{
            return $unpacked;
        }
    }

readLTriad()

static readLTriad (   $str )

static

Reads a 3-byte little-endian number

Parameters

$str

Returns

mixed

                                           {
        return unpack("V", $str . "\x00")[1];
    }

readShort()

static readShort (   $str )

static

Reads a 16-bit unsigned big-endian number

Parameters

$str

Returns

int

                                          {
        return unpack("n", $str)[1];
    }

readSignedShort()

static readSignedShort (   $str )

static

Reads a 16-bit signed big-endian number

Parameters

$str

Returns

int

                                                {
        if(PHP_INT_SIZE === 8){
            return unpack("n", $str)[1] << 48 >> 48;
        }else{
            return unpack("n", $str)[1] << 16 >> 16;
        }
    }

readTriad()

static readTriad (   $str )

static

Reads a 3-byte big-endian number

Parameters

$str

Returns

mixed

                                          {
        return unpack("N", "\x00" . $str)[1];
    }

writeBool()

static writeBool (   $b )

static

Writes a byte boolean

Parameters

$b

Returns

bool|string

                                        {
        return self::writeByte($b === true ? 1 : 0);
    }

writeByte()

static writeByte (   $c )

static

Writes an unsigned/signed byte

Parameters

$c

Returns

string

                                        {
        return chr($c);
    }

writeDouble()

static writeDouble (   $value )

static

                                              {
        return ENDIANNESS === self::BIG_ENDIAN ? pack("d", $value) : strrev(pack("d", $value));
    }

writeFloat()

static writeFloat (   $value )

static

                                             {
        return ENDIANNESS === self::BIG_ENDIAN ? pack("f", $value) : strrev(pack("f", $value));
    }

writeInt()

static writeInt (   $value )

static

                                           {
        return pack("N", $value);
    }

writeLDouble()

static writeLDouble (   $value )

static

                                               {
        return ENDIANNESS === self::BIG_ENDIAN ? strrev(pack("d", $value)) : pack("d", $value);
    }

writeLFloat()

static writeLFloat (   $value )

static

                                              {
        return ENDIANNESS === self::BIG_ENDIAN ? strrev(pack("f", $value)) : pack("f", $value);
    }

writeLInt()

static writeLInt (   $value )

static

                                            {
        return pack("V", $value);
    }

writeLLong()

static writeLLong (   $value )

static

                                             {
        return strrev(self::writeLong($value));
    }

writeLong()

static writeLong (   $value )

static

                                            {
        if(PHP_INT_SIZE === 8){
            return pack("NN", $value >> 32, $value & 0xFFFFFFFF);
        }else{
            $x = "";

            if(bccomp($value, "0") == -1){
                $value = bcadd($value, "18446744073709551616");
            }

            $x .= self::writeShort(bcmod(bcdiv($value, "281474976710656"), "65536"));
            $x .= self::writeShort(bcmod(bcdiv($value, "4294967296"), "65536"));
            $x .= self::writeShort(bcmod(bcdiv($value, "65536"), "65536"));
            $x .= self::writeShort(bcmod($value, "65536"));

            return $x;
        }
    }

writeLShort()

static writeLShort (   $value )

static

Writes a 16-bit signed/unsigned little-endian number

Parameters

$value

Returns

string

                                              {
        return pack("v", $value);
    }

writeLTriad()

static writeLTriad (   $value )

static

Writes a 3-byte little-endian number

Parameters

$value

Returns

string

                                              {
        return substr(pack("V", $value), 0, -1);
    }

writeShort()

static writeShort (   $value )

static

Writes a 16-bit signed/unsigned big-endian number

Parameters

$value

Returns

string

                                             {
        return pack("n", $value);
    }

writeTriad()

static writeTriad (   $value )

static

Writes a 3-byte big-endian number

Parameters

$value

Returns

string

                                             {
        return substr(pack("N", $value), 1);
    }

Field Documentation

BIG_ENDIAN

const BIG_ENDIAN = 0x00

LITTLE_ENDIAN

const LITTLE_ENDIAN = 0x01

---

The documentation for this class was generated from the following file:

• src/raklib/Binary.php