<h2>Editing File: /usr/local/sitepad/editor/site-data/plugins/kkart-pro/vendor/league/container/src/Container.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php declare(strict_types=1);

namespace Automattic\Kkart\Vendor\League\Container;

use Automattic\Kkart\Vendor\League\Container\Definition\{DefinitionAggregate, DefinitionInterface, DefinitionAggregateInterface};
use Automattic\Kkart\Vendor\League\Container\Exception\{NotFoundException, ContainerException};
use Automattic\Kkart\Vendor\League\Container\Inflector\{InflectorAggregate, InflectorInterface, InflectorAggregateInterface};
use Automattic\Kkart\Vendor\League\Container\ServiceProvider\{
    ServiceProviderAggregate,
    ServiceProviderAggregateInterface,
    ServiceProviderInterface
};
use Psr\Container\ContainerInterface;

class Container implements ContainerInterface
{
    /**
     * @var boolean
     */
    protected $defaultToShared = false;

    /**
     * @var DefinitionAggregateInterface
     */
    protected $definitions;

    /**
     * @var ServiceProviderAggregateInterface
     */
    protected $providers;

    /**
     * @var InflectorAggregateInterface
     */
    protected $inflectors;

    /**
     * @var ContainerInterface[]
     */
    protected $delegates = [];

    /**
     * Construct.
     *
     * @param DefinitionAggregateInterface|null      $definitions
     * @param ServiceProviderAggregateInterface|null $providers
     * @param InflectorAggregateInterface|null       $inflectors
     */
    public function __construct(
        DefinitionAggregateInterface      $definitions = null,
        ServiceProviderAggregateInterface $providers = null,
        InflectorAggregateInterface       $inflectors = null
    ) {
        $this-&gt;definitions = $definitions ?? new DefinitionAggregate;
        $this-&gt;providers   = $providers   ?? new ServiceProviderAggregate;
        $this-&gt;inflectors  = $inflectors  ?? new InflectorAggregate;

        if ($this-&gt;definitions instanceof ContainerAwareInterface) {
            $this-&gt;definitions-&gt;setLeagueContainer($this);
        }

        if ($this-&gt;providers instanceof ContainerAwareInterface) {
            $this-&gt;providers-&gt;setLeagueContainer($this);
        }

        if ($this-&gt;inflectors instanceof ContainerAwareInterface) {
            $this-&gt;inflectors-&gt;setLeagueContainer($this);
        }
    }

    /**
     * Add an item to the container.
     *
     * @param string  $id
     * @param mixed   $concrete
     * @param boolean $shared
     *
     * @return DefinitionInterface
     */
    public function add(string $id, $concrete = null, bool $shared = null) : DefinitionInterface
    {
        $concrete = $concrete ?? $id;
        $shared = $shared ?? $this-&gt;defaultToShared;

        return $this-&gt;definitions-&gt;add($id, $concrete, $shared);
    }

    /**
     * Proxy to add with shared as true.
     *
     * @param string $id
     * @param mixed  $concrete
     *
     * @return DefinitionInterface
     */
    public function share(string $id, $concrete = null) : DefinitionInterface
    {
        return $this-&gt;add($id, $concrete, true);
    }

    /**
     * Whether the container should default to defining shared definitions.
     *
     * @param boolean $shared
     *
     * @return self
     */
    public function defaultToShared(bool $shared = true) : ContainerInterface
    {
        $this-&gt;defaultToShared = $shared;

        return $this;
    }

    /**
     * Get a definition to extend.
     *
     * @param string $id [description]
     *
     * @return DefinitionInterface
     */
    public function extend(string $id) : DefinitionInterface
    {
        if ($this-&gt;providers-&gt;provides($id)) {
            $this-&gt;providers-&gt;register($id);
        }

        if ($this-&gt;definitions-&gt;has($id)) {
            return $this-&gt;definitions-&gt;getDefinition($id);
        }

        throw new NotFoundException(
            sprintf('Unable to extend alias (%s) as it is not being managed as a definition', $id)
        );
    }

    /**
     * Add a service provider.
     *
     * @param ServiceProviderInterface|string $provider
     *
     * @return self
     */
    public function addServiceProvider($provider) : self
    {
        $this-&gt;providers-&gt;add($provider);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function get($id, bool $new = false)
    {
        if ($this-&gt;definitions-&gt;has($id)) {
            $resolved = $this-&gt;definitions-&gt;resolve($id, $new);
            return $this-&gt;inflectors-&gt;inflect($resolved);
        }

        if ($this-&gt;definitions-&gt;hasTag($id)) {
            $arrayOf = $this-&gt;definitions-&gt;resolveTagged($id, $new);

            array_walk($arrayOf, function (&amp;$resolved) {
                $resolved = $this-&gt;inflectors-&gt;inflect($resolved);
            });

            return $arrayOf;
        }

        if ($this-&gt;providers-&gt;provides($id)) {
            $this-&gt;providers-&gt;register($id);

            if (!$this-&gt;definitions-&gt;has($id) &amp;&amp; !$this-&gt;definitions-&gt;hasTag($id)) {
                throw new ContainerException(sprintf('Service provider lied about providing (%s) service', $id));
            }

            return $this-&gt;get($id, $new);
        }

        foreach ($this-&gt;delegates as $delegate) {
            if ($delegate-&gt;has($id)) {
                $resolved = $delegate-&gt;get($id);
                return $this-&gt;inflectors-&gt;inflect($resolved);
            }
        }

        throw new NotFoundException(sprintf('Alias (%s) is not being managed by the container or delegates', $id));
    }

    /**
     * {@inheritdoc}
     */
    public function has($id) : bool
    {
        if ($this-&gt;definitions-&gt;has($id)) {
            return true;
        }

        if ($this-&gt;definitions-&gt;hasTag($id)) {
            return true;
        }

        if ($this-&gt;providers-&gt;provides($id)) {
            return true;
        }

        foreach ($this-&gt;delegates as $delegate) {
            if ($delegate-&gt;has($id)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Allows for manipulation of specific types on resolution.
     *
     * @param string        $type
     * @param callable|null $callback
     *
     * @return InflectorInterface
     */
    public function inflector(string $type, callable $callback = null) : InflectorInterface
    {
        return $this-&gt;inflectors-&gt;add($type, $callback);
    }

    /**
     * Delegate a backup container to be checked for services if it
     * cannot be resolved via this container.
     *
     * @param ContainerInterface $container
     *
     * @return self
     */
    public function delegate(ContainerInterface $container) : self
    {
        $this-&gt;delegates[] = $container;

        if ($container instanceof ContainerAwareInterface) {
            $container-&gt;setLeagueContainer($this);
        }

        return $this;
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fsitepad%2Feditor%2Fsite-data%2Fplugins%2Fkkart-pro%2Fvendor%2Fleague%2Fcontainer%2Fsrc'>Back to Directory</a>