抽象クラス yii\web\MultiFieldSession

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function addFlash($key, $value = true, $removeAfterAccess = true)
{
    $counters = $this->get($this->flashParam, []);
    $counters[$key] = $removeAfterAccess ? -1 : 0;
    $_SESSION[$this->flashParam] = $counters;
    if (empty($_SESSION[$key])) {
        $_SESSION[$key] = [$value];
    } elseif (is_array($_SESSION[$key])) {
        $_SESSION[$key][] = $value;
    } else {
        $_SESSION[$key] = [$_SESSION[$key], $value];
    }
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function close()
{
    if ($this->getIsActive()) {
        YII_DEBUG ? session_write_close() : @session_write_close();
    }
    $this->_forceRegenerateId = null;
}

            

                #[\ReturnTypeWillChange]
public function count()
{
    return $this->getCount();
}

            

                public function destroy()
{
    if ($this->getIsActive()) {
        $sessionId = session_id();
        $this->close();
        $this->setId($sessionId);
        $this->open();
        session_unset();
        session_destroy();
        $this->setId($sessionId);
    }
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                protected function freeze()
{
    if ($this->getIsActive()) {
        if (isset($_SESSION)) {
            $this->_frozenSessionData = $_SESSION;
        }
        $this->close();
        Yii::info('Session frozen', __METHOD__);
    }
}

            

                public function get($key, $defaultValue = null)
{
    $this->open();
    return isset($_SESSION[$key]) ? $_SESSION[$key] : $defaultValue;
}

            

                public function getAllFlashes($delete = false)
{
    $counters = $this->get($this->flashParam, []);
    $flashes = [];
    foreach (array_keys($counters) as $key) {
        if (array_key_exists($key, $_SESSION)) {
            $flashes[$key] = $_SESSION[$key];
            if ($delete) {
                unset($counters[$key], $_SESSION[$key]);
            } elseif ($counters[$key] < 0) {
                // mark for deletion in the next request
                $counters[$key] = 1;
            }
        } else {
            unset($counters[$key]);
        }
    }
    $_SESSION[$this->flashParam] = $counters;
    return $flashes;
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getCacheLimiter()
{
    return session_cache_limiter();
}

            

                public function getCookieParams()
{
    return array_merge(session_get_cookie_params(), array_change_key_case($this->_cookieParams));
}

            

                public function getCount()
{
    $this->open();
    return count($_SESSION);
}

            

                public function getFlash($key, $defaultValue = null, $delete = false)
{
    $counters = $this->get($this->flashParam, []);
    if (isset($counters[$key])) {
        $value = $this->get($key, $defaultValue);
        if ($delete) {
            $this->removeFlash($key);
        } elseif ($counters[$key] < 0) {
            // mark for deletion in the next request
            $counters[$key] = 1;
            $_SESSION[$this->flashParam] = $counters;
        }
        return $value;
    }
    return $defaultValue;
}

            

                public function getGCProbability()
{
    return (float) (ini_get('session.gc_probability') / ini_get('session.gc_divisor') * 100);
}

            

                public function getHasSessionId()
{
    if ($this->_hasSessionId === null) {
        $name = $this->getName();
        $request = Yii::$app->getRequest();
        if (!empty($_COOKIE[$name]) && ini_get('session.use_cookies')) {
            $this->_hasSessionId = true;
        } elseif (!ini_get('session.use_only_cookies') && ini_get('session.use_trans_sid')) {
            $this->_hasSessionId = $request->get($name) != '';
        } else {
            $this->_hasSessionId = false;
        }
    }
    return $this->_hasSessionId;
}

            

                public function getId()
{
    return session_id();
}

            

                public function getIsActive()
{
    return session_status() === PHP_SESSION_ACTIVE;
}

            

                #[\ReturnTypeWillChange]
public function getIterator()
{
    $this->open();
    return new SessionIterator();
}

            

                public function getName()
{
    return session_name();
}

            

                public function getSavePath()
{
    return session_save_path();
}

            

                public function getTimeout()
{
    return (int) ini_get('session.gc_maxlifetime');
}

            

                public function getUseCookies()
{
    if (ini_get('session.use_cookies') === '0') {
        return false;
    } elseif (ini_get('session.use_only_cookies') === '1') {
        return true;
    }
    return null;
}

            

                public function getUseStrictMode()
{
    if (PHP_VERSION_ID < 50502) {
        return self::$_useStrictModePolyfill;
    }
    return (bool)ini_get('session.use_strict_mode');
}

            

                public function getUseTransparentSessionID()
{
    return ini_get('session.use_trans_sid') == 1;
}

            

                public function has($key)
{
    $this->open();
    return isset($_SESSION[$key]);
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasFlash($key)
{
    return $this->getFlash($key) !== null;
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
    parent::init();
    register_shutdown_function([$this, 'close']);
    if ($this->getIsActive()) {
        Yii::warning('Session is already started', __METHOD__);
        $this->updateFlashCounters();
    }
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                #[\ReturnTypeWillChange]
public function offsetExists($offset)
{
    $this->open();
    return isset($_SESSION[$offset]);
}

            

                #[\ReturnTypeWillChange]
public function offsetGet($offset)
{
    $this->open();
    return isset($_SESSION[$offset]) ? $_SESSION[$offset] : null;
}

            

                #[\ReturnTypeWillChange]
public function offsetSet($offset, $item)
{
    $this->open();
    $_SESSION[$offset] = $item;
}

            

                #[\ReturnTypeWillChange]
public function offsetUnset($offset)
{
    $this->open();
    unset($_SESSION[$offset]);
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function open()
{
    if ($this->getIsActive()) {
        return;
    }
    $this->registerSessionHandler();
    $this->setCookieParamsInternal();
    YII_DEBUG ? session_start() : @session_start();
    if ($this->getUseStrictMode() && $this->_forceRegenerateId) {
        $this->regenerateID();
        $this->_forceRegenerateId = null;
    }
    if ($this->getIsActive()) {
        Yii::info('Session started', __METHOD__);
        $this->updateFlashCounters();
    } else {
        $error = error_get_last();
        $message = isset($error['message']) ? $error['message'] : 'Failed to start session.';
        Yii::error($message, __METHOD__);
    }
}

            

                public function regenerateID($deleteOldSession = false)
{
    if ($this->getIsActive()) {
        // add @ to inhibit possible warning due to race condition
        // https://github.com/yiisoft/yii2/pull/1812
        if (YII_DEBUG && !headers_sent()) {
            session_regenerate_id($deleteOldSession);
        } else {
            @session_regenerate_id($deleteOldSession);
        }
    }
}

            

                protected function registerSessionHandler()
{
    $sessionModuleName = session_module_name();
    if (static::$_originalSessionModule === null) {
        static::$_originalSessionModule = $sessionModuleName;
    }
    if ($this->handler !== null) {
        if (!is_object($this->handler)) {
            $this->handler = Yii::createObject($this->handler);
        }
        if (!$this->handler instanceof \SessionHandlerInterface) {
            throw new InvalidConfigException('"' . get_class($this) . '::handler" must implement the SessionHandlerInterface.');
        }
        YII_DEBUG ? session_set_save_handler($this->handler, false) : @session_set_save_handler($this->handler, false);
    } elseif ($this->getUseCustomStorage()) {
        if (YII_DEBUG) {
            session_set_save_handler(
                [$this, 'openSession'],
                [$this, 'closeSession'],
                [$this, 'readSession'],
                [$this, 'writeSession'],
                [$this, 'destroySession'],
                [$this, 'gcSession']
            );
        } else {
            @session_set_save_handler(
                [$this, 'openSession'],
                [$this, 'closeSession'],
                [$this, 'readSession'],
                [$this, 'writeSession'],
                [$this, 'destroySession'],
                [$this, 'gcSession']
            );
        }
    } elseif (
        $sessionModuleName !== static::$_originalSessionModule
        && static::$_originalSessionModule !== null
        && static::$_originalSessionModule !== 'user'
    ) {
        session_module_name(static::$_originalSessionModule);
    }
}

            

                public function remove($key)
{
    $this->open();
    if (isset($_SESSION[$key])) {
        $value = $_SESSION[$key];
        unset($_SESSION[$key]);
        return $value;
    }
    return null;
}

            

                public function removeAll()
{
    $this->open();
    foreach (array_keys($_SESSION) as $key) {
        unset($_SESSION[$key]);
    }
}

            

                public function removeAllFlashes()
{
    $counters = $this->get($this->flashParam, []);
    foreach (array_keys($counters) as $key) {
        unset($_SESSION[$key]);
    }
    unset($_SESSION[$this->flashParam]);
}

            

                public function removeFlash($key)
{
    $counters = $this->get($this->flashParam, []);
    $value = isset($_SESSION[$key], $counters[$key]) ? $_SESSION[$key] : null;
    unset($counters[$key], $_SESSION[$key]);
    $_SESSION[$this->flashParam] = $counters;
    return $value;
}

            

                public function set($key, $value)
{
    $this->open();
    $_SESSION[$key] = $value;
}

            

                public function setCacheLimiter($cacheLimiter)
{
    $this->freeze();
    session_cache_limiter($cacheLimiter);
    $this->unfreeze();
}

            

                public function setCookieParams(array $value)
{
    $this->_cookieParams = $value;
}

            

                public function setFlash($key, $value = true, $removeAfterAccess = true)
{
    $counters = $this->get($this->flashParam, []);
    $counters[$key] = $removeAfterAccess ? -1 : 0;
    $_SESSION[$key] = $value;
    $_SESSION[$this->flashParam] = $counters;
}

            

                public function setGCProbability($value)
{
    $this->freeze();
    if ($value >= 0 && $value <= 100) {
        // percent * 21474837 / 2147483647 ≈ percent * 0.01
        ini_set('session.gc_probability', floor($value * 21474836.47));
        ini_set('session.gc_divisor', 2147483647);
    } else {
        throw new InvalidArgumentException('GCProbability must be a value between 0 and 100.');
    }
    $this->unfreeze();
}

            

                public function setHasSessionId($value)
{
    $this->_hasSessionId = $value;
}

            

                public function setId($value)
{
    session_id($value);
}

            

                public function setName($value)
{
    $this->freeze();
    session_name($value);
    $this->unfreeze();
}

            

                public function setSavePath($value)
{
    $path = Yii::getAlias($value);
    if (is_dir($path)) {
        session_save_path($path);
    } else {
        throw new InvalidArgumentException("Session save path is not a valid directory: $value");
    }
}

            

                public function setTimeout($value)
{
    $this->freeze();
    ini_set('session.gc_maxlifetime', $value);
    $this->unfreeze();
}

            

                public function setUseCookies($value)
{
    $this->freeze();
    if ($value === false) {
        ini_set('session.use_cookies', '0');
        ini_set('session.use_only_cookies', '0');
    } elseif ($value === true) {
        ini_set('session.use_cookies', '1');
        ini_set('session.use_only_cookies', '1');
    } else {
        ini_set('session.use_cookies', '1');
        ini_set('session.use_only_cookies', '0');
    }
    $this->unfreeze();
}

            

                public function setUseStrictMode($value)
{
    if (PHP_VERSION_ID < 50502) {
        if ($this->getUseCustomStorage() || !$value) {
            self::$_useStrictModePolyfill = $value;
        } else {
            throw new InvalidConfigException('Enabling `useStrictMode` on PHP < 5.5.2 is only supported with custom storage classes.');
        }
    } else {
        $this->freeze();
        ini_set('session.use_strict_mode', $value ? '1' : '0');
        $this->unfreeze();
    }
}

            

                public function setUseTransparentSessionID($value)
{
    $this->freeze();
    ini_set('session.use_trans_sid', $value ? '1' : '0');
    $this->unfreeze();
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}

            

                protected function unfreeze()
{
    if (null !== $this->_frozenSessionData) {
        YII_DEBUG ? session_start() : @session_start();
        if ($this->getIsActive()) {
            Yii::info('Session unfrozen', __METHOD__);
        } else {
            $error = error_get_last();
            $message = isset($error['message']) ? $error['message'] : 'Failed to unfreeze session.';
            Yii::error($message, __METHOD__);
        }
        $_SESSION = $this->_frozenSessionData;
        $this->_frozenSessionData = null;
    }
}

            

                protected function updateFlashCounters()
{
    $counters = $this->get($this->flashParam, []);
    if (is_array($counters)) {
        foreach ($counters as $key => $count) {
            if ($count > 0) {
                unset($counters[$key], $_SESSION[$key]);
            } elseif ($count == 0) {
                $counters[$key]++;
            }
        }
        $_SESSION[$this->flashParam] = $counters;
    } else {
        // fix the unexpected problem that flashParam doesn't return an array
        unset($_SESSION[$this->flashParam]);
    }
}