Декодирует и импортирует мета-данные

@param string $encoded  закодированные данные

@return void

@since 0.3.0
503321
public function import($encoded)
    {
        $signature = substr($encoded, -32);
        $data = substr($encoded, 0, -32);
        $validSignature = $this->signature($data);
        $this->isValid = $signature == $validSignature;

        if ($data)
        {
            $data = base64_decode($data);
            if (function_exists('gzinflate'))
            {
                $data = gzinflate($data);
            }
            $data = unserialize($data);
        }

        $this->data = $data ? $data : array();
    }
211270
public function offsetUnset($offset) {
    if (is_string($offset)) {
      $this->remove($offset);
    }
    else {
      parent::offsetUnset($offset);
    }
  }
129857
private function checkEncodedData(array $encodedData): bool
    {
        $isValid = true;
        foreach ($encodedData as $locale => $namespaceResources) {
            $isValid = $isValid === true &&
                empty($locale) === false &&
                is_array($namespaceResources) === true && $this->checkNamespaceResources($namespaceResources);
        }

        return $isValid;
    }
66438
public function SetEncoding($Encoding) {
      if ($Encoding != '' && $Encoding !== FALSE) {
         // Make sure to pass through any named parameters from queries defined before the connection was opened.
         $SavedNamedParameters = $this->_NamedParameters;
         $this->_NamedParameters = array();
         $this->_NamedParameters[':encoding'] = $Encoding;
         $this->Query('set names :encoding');
         $this->_NamedParameters = $SavedNamedParameters;
      }
   }
753165
public function propagateEncoding(Encode $encode)
    {
        $this->encode = $encode;
        $this->tag->setEncoding($encode);
    }
369149
public function delete($code) {
        $service = self::get($code);

        $deleteResult = Manager::delete($service->getId());
        if (!$deleteResult->isSuccess()) {
            $this->throwException(
                __METHOD__,
                'Error deleting delivery service [%s]: %s',
                $code,
                implode('; ', $deleteResult->getErrorMessages())
            );
        }
    }
49452
public function unserialize(/* mixed */ $data): void 
    {
        $values = unserialize($data);
        foreach ($values as $key=>$value) {
                $this->$key = $value;
        }
    }
585701
public function setInput($data, $encoding = '')
    {
        $this->_input    = $data;
        $this->_encoding = $encoding;
        $this->reset();
    }
330841
public function offsetUnset($offset)
    {
        $this->str = $this->getPrefix($offset) . chr(0x00) . $this->getSuffix($offset);
    }
1169477
public function decode($encoded)
    {
        $defaults = [
            'sub' => null,
            'iat' => null,
            'exp' => null,
        ];

        $payload = (array) JWT::decode($encoded, $this->secret, [$this->algoritm]) + $defaults;

        $claims = array_diff_key($payload, $defaults);

        $expireAt = new DateTimeImmutable('@'.$payload['exp']);
        $issuedAt = new DateTimeImmutable('@'.$payload['iat']);

        return new WebToken($payload['sub'], $issuedAt, $expireAt, $claims);
    }
539542
public function offsetUnset($offset)
    {
        $keys = explode($this->keySeparator, $offset);

        $keyCount = count($keys);

        $array = &$this->values;

        while ($keyCount > 1) {
            $key = array_shift($keys);

            if (isset($array[$key]) && is_array($array[$key])) {
                $array = &$array[$key];
            }

            --$keyCount;
        }

        unset($array[array_shift($keys)]);
    }
1256280
protected function decodePunycode($encoded)
    {
        $matches = array();
        $found   = preg_match('/([^a-z0-9\x2d]{1,10})$/i', $encoded);
        if (empty($encoded) || (count($matches) > 0)) {
            // no punycode encoded string, return as is
            $this->_error(self::CANNOT_DECODE_PUNYCODE);
            return false;
        }

        $separator = strrpos($encoded, '-');
        if ($separator > 0) {
            for ($x = 0; $x < $separator; ++$x) {
                // prepare decoding matrix
                $decoded[] = ord($encoded[$x]);
            }
        } else {
            $this->_error(self::CANNOT_DECODE_PUNYCODE);
            return false;
        }

        $lengthd = count($decoded);
        $lengthe = strlen($encoded);

        // decoding
        $init  = true;
        $base  = 72;
        $index = 0;
        $char  = 0x80;

        for ($indexe = ($separator) ? ($separator + 1) : 0; $indexe < $lengthe; ++$lengthd) {
            for ($old_index = $index, $pos = 1, $key = 36; 1 ; $key += 36) {
                $hex   = ord($encoded[$indexe++]);
                $digit = ($hex - 48 < 10) ? $hex - 22
                       : (($hex - 65 < 26) ? $hex - 65
                       : (($hex - 97 < 26) ? $hex - 97
                       : 36));

                $index += $digit * $pos;
                $tag    = ($key <= $base) ? 1 : (($key >= $base + 26) ? 26 : ($key - $base));
                if ($digit < $tag) {
                    break;
                }

                $pos = (int) ($pos * (36 - $tag));
            }

            $delta   = intval($init ? (($index - $old_index) / 700) : (($index - $old_index) / 2));
            $delta  += intval($delta / ($lengthd + 1));
            for ($key = 0; $delta > 910 / 2; $key += 36) {
                $delta = intval($delta / 35);
            }

            $base   = intval($key + 36 * $delta / ($delta + 38));
            $init   = false;
            $char  += (int) ($index / ($lengthd + 1));
            $index %= ($lengthd + 1);
            if ($lengthd > 0) {
                for ($i = $lengthd; $i > $index; $i--) {
                    $decoded[$i] = $decoded[($i - 1)];
                }
            }

            $decoded[$index++] = $char;
        }

        // convert decoded ucs4 to utf8 string
        foreach ($decoded as $key => $value) {
            if ($value < 128) {
                $decoded[$key] = chr($value);
            } elseif ($value < (1 << 11)) {
                $decoded[$key]  = chr(192 + ($value >> 6));
                $decoded[$key] .= chr(128 + ($value & 63));
            } elseif ($value < (1 << 16)) {
                $decoded[$key]  = chr(224 + ($value >> 12));
                $decoded[$key] .= chr(128 + (($value >> 6) & 63));
                $decoded[$key] .= chr(128 + ($value & 63));
            } elseif ($value < (1 << 21)) {
                $decoded[$key]  = chr(240 + ($value >> 18));
                $decoded[$key] .= chr(128 + (($value >> 12) & 63));
                $decoded[$key] .= chr(128 + (($value >> 6) & 63));
                $decoded[$key] .= chr(128 + ($value & 63));
            } else {
                $this->_error(self::CANNOT_DECODE_PUNYCODE);
                return false;
            }
        }

        return implode($decoded);
    }
902380
public static function getType(array $encoded): int
    {
        assert(array_key_exists(static::TYPE, $encoded) === true);

        return $encoded[static::TYPE];
    }
1355963
public function setConfirmCode($code)
    {
        if (!$this->confirmCodeAttribute || empty($this->confirmCodeAttribute)) {
            return;
        }
        $confirmCodeAttribute = $this->confirmCodeAttribute;
        $this->$confirmCodeAttribute = $code;
        if (!$this->confirmTimeAttribute) {
            return;
        }
        $confirmTimeAttribute = $this->confirmTimeAttribute;
        if (!empty($code)) {
            $this->$confirmTimeAttribute = date('Y-m-d H:i:s');
            return;
        }
        $this->$confirmTimeAttribute = $this->initConfirmTime;
    }
1040589
protected function updateLanguage($code)
    {
        if (!$this->isError() && !$this->language->update($code, $this->getSubmitted())) {
            $this->errorAndExit($this->text('Unexpected result'));
        }
    }
676607
public function write( $value ): void {
		if ( $value !== $this->value ) {
			$this->emit( GPIO::BEFORE_VALUE_CHANGE_EVENT, [ $this ] );
			$value = boolval( $value ) ? 1 : 0;
			fwrite( $this->fileHandler, "$value", 1 );
			$this->value = $value;
			$this->emit( GPIO::AFTER_VALUE_CHANGE_EVENT, [ $this ] );
		}
	}
624169
public function offsetUnset($offset)
    {
        unset($this->rawData[$offset]);
        unset($this->typeData[$offset]);
        $rawKeys = array_keys($this->rawData);
        $typeKeys = array_keys($this->typeData);
        $keys = array_merge($rawKeys, $typeKeys);
        $this->keys = array_unique($keys);
    }