Takes a serialized variable and unserializes it back into it's
original state.

@param string $SerializedString A json or php serialized string to be unserialized.
@return mixed
556436
public static function Unserialize($SerializedString) {
		$Result = $SerializedString;
		
      if(is_string($SerializedString)) {
			if(substr_compare('a:', $SerializedString, 0, 2) === 0 || substr_compare('O:', $SerializedString, 0, 2) === 0)
				$Result = unserialize($SerializedString);
			elseif(substr_compare('obj:', $SerializedString, 0, 4) === 0)
            $Result = json_decode(substr($SerializedString, 4), FALSE);
         elseif(substr_compare('arr:', $SerializedString, 0, 4) === 0)
            $Result = json_decode(substr($SerializedString, 4), TRUE);
      }
      return $Result;
   }
722894
public function unserialize($serialized)
    {
        list($this->dsn, $this->user, $this->password, $this->options) = unserialize($serialized);
    }
344055
public static function decode($string)
    {
        if (!$string) {
            return new ArrayObject();
        }

        try {
            $array = unserialize($string);
        } catch (\Exception $e) {
            throw new PhpException("Serialize Error: " . $e->getMessage());
        }

        if (!is_array($array)) {
            $array = [];
        }

        return ArrayObject::make($array);
    }
743756
public function unserialize($serialized)
    {
        $data = unserialize($serialized);

        $this->credentials   = $data['credentials'];
        $this->loginResult   = $data['loginResult'];
        $this->debug         = $data['debug'];
        $this->lastLoginTime = $data['lastLoginTime'];

        parent::unserialize($data['__parentData']);
    }
1239879
public function unserialize($serialized)
    {
        $data = unserialize($serialized);
        $this->coverage = $data['coverage'];
        $this->filter   = $data['filter'];
        $this->options  = $data['options'];
        $this->path     = $data['path'];
    }
492005
public function unserialize($serializedObject)
    {
        $objectVars = unserialize($serializedObject);

        foreach ($objectVars as $key => $value) {
            $this->{$key} = $value;
        }
    }
1237924
public function unserialize($string)
    {
        $data = unserialize($string);
        foreach ($data as $key => $val) {
            $this->$key = $val;
        }
    }
482946
public function unserialize($serialized)
    {
        $results = (array)(unserialize($serialized) ?: []);
        $this->_results = SplFixedArray::fromArray($results);
        $this->_useBuffering = true;
        $this->_count = $this->_results->count();
    }
525
public static function unserializeFromStringRepresentation($string)
    {
        if (!preg_match('~k:(?P<k>\d+)/m:(?P<m>\d+)\((?P<bitfield>[0-9a-zA-Z+/=]+)\)~', $string, $matches)) {
            throw new InvalidArgumentException('Invalid string representation');
        }
        $bf = new self((int) $matches['m'], (int) $matches['k']);
        $bf->bitField = base64_decode($matches['bitfield']);
        return $bf;
    }
741993
public function unserialize($serialized)
    {
        list($this->message, $this->code, $this->file, $this->line) = unserialize($serialized);
    }
82589
public function unserialize($serialized)
    {
        list (
            $this->id,
            $this->nameId,
            $this->institution,
            $this->email,
            $this->commonName,
            $this->preferredLocale
        ) = unserialize($serialized);
    }
1296380
public function unserialize($serialized) {
		$arr = \unserialize($serialized);
		$this->_Value = $arr[0];
		$this->_Encoding = $arr[1];
	}
930410
public function unserialize($data)
    {
        $object = @unserialize($data);
        if($object === false) {
            throw new SerializerException("Unable to unserialize data: " . $data);
        }

        return $object;
    }
1269528
public static function maybe_unserialize($data)
    {
        // If it isn't a string, it isn't serialized
        if (!is_string($data)) {
            return $data;
        }

        $data = trim($data);

        // Is it the serialized NULL value?
        if ($data === 'N;') {
            return null;
        }

        $length = strlen($data);

        // Check some basic requirements of all serialized strings
        if ($length < 4 || $data[1] !== ':' || ($data[$length - 1] !== ';' && $data[$length - 1] !== '}')) {
            return $data;
        }

        // $data is the serialized false value
        if ($data === 'b:0;') {
            return false;
        }

        // Don't attempt to unserialize data that isn't serialized
        $uns = @unserialize($data);

        // Data failed to unserialize?
        if ($uns === false) {
            $uns = @unserialize(self::fix_broken_serialization($data));

            if ($uns === false) {
                return $data;
            } else {
                return $uns;
            }
        } else {
            return $uns;
        }
    }
367910
public function unserialize($serialized)
    {
        $payload = unserialize($serialized);

        // We will extract the variables into the current scope so that as the Closure
        // is built it will inherit the scope it had before it was serialized which
        // will emulate the Closures existing in that scope instead of right now.
        extract($payload['variables']);

        eval('$this->closure = '.$payload['code'].';');

        $this->reflection = new ReflectionFunction($this->closure);
    }
545031
public function unserialize($serialized) {
            $s = unserialize($serialized);
            $this->defaults = $s[0];
            $this->custom = $s[1];
            $this->merge();
        }
181883
public function unserialize($serialized)
    {
        $unserialized = unserialize($serialized);
        $this->__construct($unserialized['tokens']);
        $this->seek($unserialized['index']);
    }