Zend_Json_Encoder Class Reference

Static Public Member Functions
static	encode ($value, $cycleCheck=false, $options=array())
static	encodeClass ($className, $package='')
static	encodeClasses (array $classNames, $package='')
static	encodeUnicodeString ($value)

Protected Member Functions
	__construct ($cycleCheck=false, $options=array())
	_encodeValue (&$value)
	_encodeObject (&$value)
	_wasVisited (&$value)
	_encodeArray (&$array)
	_encodeDatum (&$value)
	_encodeString (&$string)

Static Protected Member Functions
static	_utf82utf16 ($utf8)

Protected Attributes
	$_cycleCheck
	$_options = array()
	$_visited = array()

Detailed Description

Definition at line 30 of file Encoder.php.

Constructor & Destructor Documentation

__construct()

__construct (   $cycleCheck = false,   $options = array()  )

protected

Constructor

Parameters

boolean	$cycleCheck	Whether or not to check for recursion when encoding
array	$options	Additional options used during encoding

Returns

void

Definition at line 60 of file Encoder.php.

    {
        $this->_cycleCheck = $cycleCheck;
        $this->_options = $options;
    }

Member Function Documentation

_encodeArray()

_encodeArray ( &  $array )

protected

JSON encode an array value

Recursively encodes each value of an array and returns a JSON encoded array string.

Arrays are defined as integer-indexed arrays starting at index 0, where the last index is (count($array) -1); any deviation from that is considered an associative array, and will be encoded as such.

Parameters

array&

$array

Returns

string

Definition at line 192 of file Encoder.php.

    {
        $tmpArray = array();

        // Check for associative array
        if (!empty($array) && (array_keys($array) !== range(0, count($array) - 1))) {
            // Associative array
            $result = '{';
            foreach ($array as $key => $value) {
                $key = (string) $key;
                $tmpArray[] = $this->_encodeString($key)
                            . ':'
                            . $this->_encodeValue($value);
            }
            $result .= implode(',', $tmpArray);
            $result .= '}';
        } else {
            // Indexed array
            $result = '[';
            $length = count($array);
            for ($i = 0; $i < $length; $i++) {
                $tmpArray[] = $this->_encodeValue($array[$i]);
            }
            $result .= implode(',', $tmpArray);
            $result .= ']';
        }

        return $result;
    }

_encodeDatum()

_encodeDatum ( &  $value )

protected

JSON encode a basic data type (string, number, boolean, null)

If value type is not a string, number, boolean, or null, the string 'null' is returned.

Parameters

mixed&

$value

Returns

string

Definition at line 232 of file Encoder.php.

    {
        $result = 'null';

        if (is_int($value) || is_float($value)) {
            $result = (string) $value;
            $result = str_replace(",", ".", $result);
        } elseif (is_string($value)) {
            $result = $this->_encodeString($value);
        } elseif (is_bool($value)) {
            $result = $value ? 'true' : 'false';
        }

        return $result;
    }

_encodeObject()

_encodeObject ( &  $value )

protected

Encode an object to JSON by encoding each of the public properties

A special property is added to the JSON object called '__className' that contains the name of the class of $value. This is used to decode the object on the client into a specific class.

Parameters

object

$value

Returns

string

Exceptions

Zend_Json_Exception

If recursive checks are enabled and the object has been serialized previously

Definition at line 114 of file Encoder.php.

    {
        if ($this->_cycleCheck) {
            if ($this->_wasVisited($value)) {

                if (isset($this->_options['silenceCyclicalExceptions'])
                    && $this->_options['silenceCyclicalExceptions']===true) {

                    return '"* RECURSION (' . get_class($value) . ') *"';

                } else {
                    #require_once 'Zend/Json/Exception.php';
                    throw new Zend_Json_Exception(
                        'Cycles not supported in JSON encoding, cycle introduced by '
                        . 'class "' . get_class($value) . '"'
                    );
                }
            }

            $this->_visited[] = $value;
        }

        $props = '';
        if (method_exists($value, 'toJson')) {
            $props =',' . preg_replace("/^\{(.*)\}$/","\\1",$value->toJson());
        } else {
            if ($value instanceof IteratorAggregate) {
                $propCollection = $value->getIterator();
            } elseif ($value instanceof Iterator) {
                $propCollection = $value;
            } else {
                $propCollection = get_object_vars($value);
            }

            foreach ($propCollection as $name => $propValue) {
                if (isset($propValue)) {
                    $props .= ','
                            . $this->_encodeString($name)
                            . ':'
                            . $this->_encodeValue($propValue);
                }
            }
        }
        $className = get_class($value);
        return '{"__className":' . $this->_encodeString($className)
                . $props . '}';
    }

_encodeString()

_encodeString ( &  $string )

protected

JSON encode a string value by escaping characters as necessary

Parameters

string&

$value

Returns

string

Definition at line 255 of file Encoder.php.

    {
        // Escape these characters with a backslash:
        // " \ / \n \r \t \b \f
        $search  = array('\\', "\n", "\t", "\r", "\b", "\f", '"', '/');
        $replace = array('\\\\', '\\n', '\\t', '\\r', '\\b', '\\f', '\"', '\\/');
        $string  = str_replace($search, $replace, $string);

        // Escape certain ASCII characters:
        // 0x08 => \b
        // 0x0c => \f
        $string = str_replace(array(chr(0x08), chr(0x0C)), array('\b', '\f'), $string);
        $string = self::encodeUnicodeString($string);

        return '"' . $string . '"';
    }

_encodeValue()

_encodeValue ( &  $value )

protected

Recursive driver which determines the type of value to be encoded and then dispatches to the appropriate method. $values are either

• objects (returns from _encodeObject())
• arrays (returns from _encodeArray())
• basic datums (e.g. numbers or strings) (returns from _encodeDatum())

Parameters

mixed

$value

The value to be encoded

Returns

string Encoded value

Definition at line 90 of file Encoder.php.

    {
        if (is_object($value)) {
            return $this->_encodeObject($value);
        } else if (is_array($value)) {
            return $this->_encodeArray($value);
        }

        return $this->_encodeDatum($value);
    }

_utf82utf16()

static _utf82utf16 (   $utf8 )

staticprotected

Convert a string from one UTF-8 char to one UTF-16 char.

Normally should be handled by mb_convert_encoding, but provides a slower PHP-only method for installations that lack the multibye string extension.

This method is from the Solar Framework by Paul M. Jones

string $utf8 UTF-8 character string UTF-16 character

Definition at line 545 of file Encoder.php.

    {
        // Check for mb extension otherwise do by hand.
        if( function_exists('mb_convert_encoding') ) {
            return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
        }

        switch (strlen($utf8)) {
            case 1:
                // this case should never be reached, because we are in ASCII range
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return $utf8;

            case 2:
                // return a UTF-16 character from a 2-byte UTF-8 char
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0x07 & (ord($utf8{0}) >> 2))
                     . chr((0xC0 & (ord($utf8{0}) << 6))
                         | (0x3F & ord($utf8{1})));

            case 3:
                // return a UTF-16 character from a 3-byte UTF-8 char
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr((0xF0 & (ord($utf8{0}) << 4))
                         | (0x0F & (ord($utf8{1}) >> 2)))
                     . chr((0xC0 & (ord($utf8{1}) << 6))
                         | (0x7F & ord($utf8{2})));
        }

        // ignoring UTF-32 for now, sorry
        return '';
    }

_wasVisited()

_wasVisited ( &  $value )

protected

Determine if an object has been serialized already

Parameters

mixed

$value

Returns

boolean

Definition at line 169 of file Encoder.php.

    {
        if (in_array($value, $this->_visited, true)) {
            return true;
        }

        return false;
    }

encode()

static encode (   $value,   $cycleCheck = false,   $options = array()  )

static

Use the JSON encoding scheme for the value specified

Parameters

mixed	$value	The value to be encoded
boolean	$cycleCheck	Whether or not to check for possible object recursion when encoding
array	$options	Additional options used during encoding

Returns

string The encoded value

Definition at line 74 of file Encoder.php.

    {
        $encoder = new self(($cycleCheck) ? true : false, $options);
        return $encoder->_encodeValue($value);
    }

encodeClass()

static encodeClass (   $className,   $package = ''  )

static

Encodes the given $className into the class2 model of encoding PHP classes into JavaScript class2 classes. NOTE: Currently only public methods and variables are proxied onto the client machine

Parameters

string	$className	The name of the class, the class must be instantiable using a null constructor
string	$package	Optional package name appended to JavaScript proxy class name

Returns

string The class2 (JavaScript) encoding of the class

Exceptions

Zend_Json_Exception

Definition at line 405 of file Encoder.php.

    {
        $cls = new ReflectionClass($className);
        if (! $cls->isInstantiable()) {
            #require_once 'Zend/Json/Exception.php';
            throw new Zend_Json_Exception("$className must be instantiable");
        }

        return "Class.create('$package$className',{"
                . self::_encodeConstants($cls)    .","
                . self::_encodeMethods($cls)      .","
                . self::_encodeVariables($cls)    .'});';
    }

encodeClasses()

static encodeClasses ( array  $classNames,   $package = ''  )

static

Encode several classes at once

Returns JSON encoded classes, using encodeClass().

Parameters

array	$classNames
string	$package

Returns

string

Definition at line 429 of file Encoder.php.

    {
        $result = '';
        foreach ($classNames as $className) {
            $result .= self::encodeClass($className, $package);
        }

        return $result;
    }

encodeUnicodeString()

static encodeUnicodeString (   $value )

static

Encode Unicode Characters to \u0000 ASCII syntax.

This algorithm was originally developed for the Solar Framework by Paul M. Jones

http://svn.solarphp.com/core/trunk/Solar/Json.php string $value string

Iterate over every character in the string, escaping with a slash or encoding to UTF-8 where necessary

Definition at line 450 of file Encoder.php.

    {
        $strlen_var = strlen($value);
        $ascii = "";

        for($i = 0; $i < $strlen_var; $i++) {
            $ord_var_c = ord($value[$i]);

            switch (true) {
                case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
                    // characters U-00000000 - U-0000007F (same as ASCII)
                    $ascii .= $value[$i];
                    break;

                case (($ord_var_c & 0xE0) == 0xC0):
                    // characters U-00000080 - U-000007FF, mask 110XXXXX
                    // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                    $char = pack('C*', $ord_var_c, ord($value[$i + 1]));
                    $i += 1;
                    $utf16 = self::_utf82utf16($char);
                    $ascii .= sprintf('\u%04s', bin2hex($utf16));
                    break;

                case (($ord_var_c & 0xF0) == 0xE0):
                    // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                    // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                    $char = pack('C*', $ord_var_c,
                                 ord($value[$i + 1]),
                                 ord($value[$i + 2]));
                    $i += 2;
                    $utf16 = self::_utf82utf16($char);
                    $ascii .= sprintf('\u%04s', bin2hex($utf16));
                    break;

                case (($ord_var_c & 0xF8) == 0xF0):
                    // characters U-00010000 - U-001FFFFF, mask 11110XXX
                    // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                    $char = pack('C*', $ord_var_c,
                                 ord($value[$i + 1]),
                                 ord($value[$i + 2]),
                                 ord($value[$i + 3]));
                    $i += 3;
                    $utf16 = self::_utf82utf16($char);
                    $ascii .= sprintf('\u%04s', bin2hex($utf16));
                    break;

                case (($ord_var_c & 0xFC) == 0xF8):
                    // characters U-00200000 - U-03FFFFFF, mask 111110XX
                    // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                    $char = pack('C*', $ord_var_c,
                                 ord($value[$i + 1]),
                                 ord($value[$i + 2]),
                                 ord($value[$i + 3]),
                                 ord($value[$i + 4]));
                    $i += 4;
                    $utf16 = self::_utf82utf16($char);
                    $ascii .= sprintf('\u%04s', bin2hex($utf16));
                    break;

                case (($ord_var_c & 0xFE) == 0xFC):
                    // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                    // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                    $char = pack('C*', $ord_var_c,
                                 ord($value[$i + 1]),
                                 ord($value[$i + 2]),
                                 ord($value[$i + 3]),
                                 ord($value[$i + 4]),
                                 ord($value[$i + 5]));
                    $i += 5;
                    $utf16 = self::_utf82utf16($char);
                    $ascii .= sprintf('\u%04s', bin2hex($utf16));
                    break;
            }
        }

        return $ascii;
     }

Field Documentation

$_cycleCheck

$_cycleCheck

protected

Definition at line 37 of file Encoder.php.

$_options

$_options = array()

protected

Definition at line 44 of file Encoder.php.

$_visited

$_visited = array()

protected

Definition at line 51 of file Encoder.php.

---

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

• vendor/magento/zendframework1/library/Zend/Json/Encoder.php