<?php

namespace { require_once __DIR__.'/autoload.php'; }

namespace Symfony\Component\DependencyInjection

{

interface ContainerAwareInterface

{

    function setContainer(ContainerInterface $container = null);

}

}

namespace Symfony\Component\DependencyInjection

{

interface ContainerInterface

{

    const EXCEPTION_ON_INVALID_REFERENCE = 1;

    const NULL_ON_INVALID_REFERENCE      = 2;

    const IGNORE_ON_INVALID_REFERENCE    = 3;

    const SCOPE_CONTAINER                = 'container';

    const SCOPE_PROTOTYPE                = 'prototype';

    function set($id, $service, $scope = self::SCOPE_CONTAINER);

    function get($id, $invalidBehavior = self::EXCEPTION_ON_INVALID_REFERENCE);

    function has($id);

    function getParameter($name);

    function hasParameter($name);

    function setParameter($name, $value);

    function enterScope($name);

    function leaveScope($name);

    function addScope(ScopeInterface $scope);

    function hasScope($name);

    function isScopeActive($name);

}

}

namespace Symfony\Component\DependencyInjection

{

use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;

use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;

use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;

use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;

class Container implements ContainerInterface

{

    protected $parameterBag;

    protected $services;

    protected $scopes;

    protected $scopeChildren;

    protected $scopedServices;

    protected $scopeStacks;

    protected $loading = array();

    public function __construct(ParameterBagInterface $parameterBag = null)

    {

        $this->parameterBag = null === $parameterBag ? new ParameterBag() : $parameterBag;

        $this->services       = array();

        $this->scopes         = array();

        $this->scopeChildren  = array();

        $this->scopedServices = array();

        $this->scopeStacks    = array();

        $this->set('service_container', $this);

    }

    public function compile()

    {

        $this->parameterBag->resolve();

        $this->parameterBag = new FrozenParameterBag($this->parameterBag->all());

    }

    public function isFrozen()

    {

        return $this->parameterBag instanceof FrozenParameterBag;

    }

    public function getParameterBag()

    {

        return $this->parameterBag;

    }

    public function getParameter($name)

    {

        return $this->parameterBag->get($name);

    }

    public function hasParameter($name)

    {

        return $this->parameterBag->has($name);

    }

    public function setParameter($name, $value)

    {

        $this->parameterBag->set($name, $value);

    }

    public function set($id, $service, $scope = self::SCOPE_CONTAINER)

    {

        if (self::SCOPE_PROTOTYPE === $scope) {

            throw new \InvalidArgumentException('You cannot set services of scope "prototype".');

        }

        $id = strtolower($id);

        if (self::SCOPE_CONTAINER !== $scope) {

            if (!isset($this->scopedServices[$scope])) {

                throw new \RuntimeException('You cannot set services of inactive scopes.');

            }

            $this->scopedServices[$scope][$id] = $service;

        }

        $this->services[$id] = $service;

    }

    public function has($id)

    {

        $id = strtolower($id);

        return isset($this->services[$id]) || method_exists($this, 'get'.strtr($id, array('_' => '', '.' => '_')).'Service');

    }

    public function get($id, $invalidBehavior = self::EXCEPTION_ON_INVALID_REFERENCE)

    {

        $id = strtolower($id);

        if (isset($this->services[$id])) {

            return $this->services[$id];

        }

        if (isset($this->loading[$id])) {

            throw new ServiceCircularReferenceException($id, array_keys($this->loading));

        }

        if (method_exists($this, $method = 'get'.strtr($id, array('_' => '', '.' => '_')).'Service')) {

            $this->loading[$id] = true;

            try {

                $service = $this->$method();

            } catch (\Exception $e) {

                unset($this->loading[$id]);

                throw $e;

            }

            unset($this->loading[$id]);

            return $service;

        }

        if (self::EXCEPTION_ON_INVALID_REFERENCE === $invalidBehavior) {

            throw new ServiceNotFoundException($id);

        }

    }

    public function getServiceIds()

    {

        $ids = array();

        $r = new \ReflectionClass($this);

        foreach ($r->getMethods() as $method) {

            if (preg_match('/^get(.+)Service$/', $method->getName(), $match)) {

                $ids[] = self::underscore($match[1]);

            }

        }

        return array_unique(array_merge($ids, array_keys($this->services)));

    }

    public function enterScope($name)

    {

        if (!isset($this->scopes[$name])) {

            throw new \InvalidArgumentException(sprintf('The scope "%s" does not exist.', $name));

        }

        if (self::SCOPE_CONTAINER !== $this->scopes[$name] && !isset($this->scopedServices[$this->scopes[$name]])) {

            throw new \RuntimeException(sprintf('The parent scope "%s" must be active when entering this scope.', $this->scopes[$name]));

        }

                                if (isset($this->scopedServices[$name])) {

            $services = array($this->services, $name => $this->scopedServices[$name]);

            unset($this->scopedServices[$name]);

            foreach ($this->scopeChildren[$name] as $child) {

                $services[$child] = $this->scopedServices[$child];

                unset($this->scopedServices[$child]);

            }

                        $this->services = call_user_func_array('array_diff_key', $services);

            array_shift($services);

                        if (!isset($this->scopeStacks[$name])) {

                $this->scopeStacks[$name] = new \SplStack();

            }

            $this->scopeStacks[$name]->push($services);

        }

        $this->scopedServices[$name] = array();

    }

    public function leaveScope($name)

    {

        if (!isset($this->scopedServices[$name])) {

            throw new \InvalidArgumentException(sprintf('The scope "%s" is not active.', $name));

        }

                        $services = array($this->services, $this->scopedServices[$name]);

        unset($this->scopedServices[$name]);

        foreach ($this->scopeChildren[$name] as $child) {

            if (!isset($this->scopedServices[$child])) {

                continue;

            }

            $services[] = $this->scopedServices[$child];

            unset($this->scopedServices[$child]);

        }

        $this->services = call_user_func_array('array_diff_key', $services);

                if (isset($this->scopeStacks[$name]) && count($this->scopeStacks[$name]) > 0) {

            $services = $this->scopeStacks[$name]->pop();

            $this->scopedServices += $services;

            array_unshift($services, $this->services);

            $this->services = call_user_func_array('array_merge', $services);

        }

    }

    public function addScope(ScopeInterface $scope)

    {

        $name = $scope->getName();

        $parentScope = $scope->getParentName();

        if (self::SCOPE_CONTAINER === $name || self::SCOPE_PROTOTYPE === $name) {

            throw new \InvalidArgumentException(sprintf('The scope "%s" is reserved.', $name));

        }

        if (isset($this->scopes[$name])) {

            throw new \InvalidArgumentException(sprintf('A scope with name "%s" already exists.', $name));

        }

        if (self::SCOPE_CONTAINER !== $parentScope && !isset($this->scopes[$parentScope])) {

            throw new \InvalidArgumentException(sprintf('The parent scope "%s" does not exist, or is invalid.', $parentScope));

        }

        $this->scopes[$name] = $parentScope;

        $this->scopeChildren[$name] = array();

                while ($parentScope !== self::SCOPE_CONTAINER) {

            $this->scopeChildren[$parentScope][] = $name;

            $parentScope = $this->scopes[$parentScope];

        }

    }

    public function hasScope($name)

    {

        return isset($this->scopes[$name]);

    }

    public function isScopeActive($name)

    {

        return isset($this->scopedServices[$name]);

    }

    static public function camelize($id)

    {

        return preg_replace_callback('/(^|_|\.)+(.)/', function ($match) { return ('.' === $match[1] ? '_' : '').strtoupper($match[2]); }, $id);

    }

    static public function underscore($id)

    {

        return strtolower(preg_replace(array('/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'), array('\\1_\\2', '\\1_\\2'), strtr($id, '_', '.')));

    }

}

}

namespace Symfony\Component\HttpKernel

{

use Symfony\Component\HttpFoundation\Request;

use Symfony\Component\HttpFoundation\Response;

interface HttpKernelInterface

{

    const MASTER_REQUEST = 1;

    const SUB_REQUEST = 2;

    function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true);

}

}

namespace Symfony\Component\HttpKernel

{

use Symfony\Component\DependencyInjection\ContainerInterface;

use Symfony\Component\HttpKernel\HttpKernelInterface;

use Symfony\Component\HttpKernel\Bundle\BundleInterface;

use Symfony\Component\Config\Loader\LoaderInterface;

interface KernelInterface extends HttpKernelInterface, \Serializable

{

    function registerBundles();

    function registerContainerConfiguration(LoaderInterface $loader);

    function boot();

    function shutdown();

    function getBundles();

    function isClassInActiveBundle($class);

    function getBundle($name, $first = true);

    function locateResource($name, $dir = null, $first = true);

    function getName();

    function getEnvironment();

    function isDebug();

    function getRootDir();

    function getContainer();

    function getStartTime();

    function getCacheDir();

    function getLogDir();

}

}

namespace Symfony\Component\HttpKernel

{

use Symfony\Component\DependencyInjection\ContainerInterface;

use Symfony\Component\DependencyInjection\ContainerBuilder;

use Symfony\Component\DependencyInjection\Dumper\PhpDumper;

use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;

use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;

use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;

use Symfony\Component\DependencyInjection\Loader\IniFileLoader;

use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;

use Symfony\Component\DependencyInjection\Loader\ClosureLoader;

use Symfony\Component\HttpFoundation\Request;

use Symfony\Component\HttpKernel\HttpKernelInterface;

use Symfony\Component\HttpKernel\Bundle\BundleInterface;

use Symfony\Component\HttpKernel\Config\FileLocator;

use Symfony\Component\HttpKernel\DependencyInjection\MergeExtensionConfigurationPass;

use Symfony\Component\HttpKernel\DependencyInjection\AddClassesToCachePass;

use Symfony\Component\HttpKernel\DependencyInjection\Extension as DIExtension;

use Symfony\Component\HttpKernel\Debug\ErrorHandler;

use Symfony\Component\HttpKernel\Debug\ExceptionHandler;

use Symfony\Component\Config\Loader\LoaderResolver;

use Symfony\Component\Config\Loader\DelegatingLoader;

use Symfony\Component\Config\ConfigCache;

use Symfony\Component\ClassLoader\ClassCollectionLoader;

use Symfony\Component\ClassLoader\DebugUniversalClassLoader;

abstract class Kernel implements KernelInterface

{

    protected $bundles;

    protected $bundleMap;

    protected $container;

    protected $rootDir;

    protected $environment;

    protected $debug;

    protected $booted;

    protected $name;

    protected $startTime;

    protected $classes;

    const VERSION = '2.0.1';

    public function __construct($environment, $debug)

    {

        $this->environment = $environment;

        $this->debug = (Boolean) $debug;

        $this->booted = false;

        $this->rootDir = $this->getRootDir();

        $this->name = preg_replace('/[^a-zA-Z0-9_]+/', '', basename($this->rootDir));

        $this->classes = array();

        if ($this->debug) {

            $this->startTime = microtime(true);

        }

        $this->init();

    }

    public function init()

    {

        if ($this->debug) {

            ini_set('display_errors', 1);

            error_reporting(-1);

            DebugUniversalClassLoader::enable();

            ErrorHandler::register();

            if ('cli' !== php_sapi_name()) {

                ExceptionHandler::register();

            }

        } else {

            ini_set('display_errors', 0);

        }

    }

    public function __clone()

    {

        if ($this->debug) {

            $this->startTime = microtime(true);

        }

        $this->booted = false;

        $this->container = null;

    }

    public function boot()

    {

        if (true === $this->booted) {

            return;

        }

                $this->initializeBundles();

                $this->initializeContainer();

        foreach ($this->getBundles() as $bundle) {

            $bundle->setContainer($this->container);

            $bundle->boot();

        }

        $this->booted = true;

    }

    public function shutdown()

    {

        if (false === $this->booted) {

            return;

        }