Pause the container id

@param string $container container ID
@return PromiseInterface Promise<null>
@link https://docs.docker.com/reference/api/docker_remote_api_v1.15/#pause-a-container
542735
public function containerPause($container)
    {
        return $this->browser->post(
            $this->uri->expand(
                '/containers/{container}/pause',
                array(
                    'container' => $container
                )
            )
        )->then(array($this->parser, 'expectEmpty'));
    }
765868
public function setContainer(Container $container = null)
    {
        $this->container = $container;
        $this->parameters = array();

        return $this;
    }
929852
public final function register(CacheInterface $container): ServiceInterface
   {
       foreach ($this->service as $key => &$value) {
           $container->set($key, $value);
       }
       return $this;
   }
747395
protected function addQueueAdapter(Container $container)
    {
        $container[static::QUEUE_ADAPTER] = function () use ($container) {
            return $container->getLocator()->rabbitMq()->client()->createQueueAdapter();
        };

        return $container;
    }
433674
public function createService(ServiceLocatorInterface $container)
    {
        // Retrieve the parent container when under zend-servicemanager v2
        if (method_exists($container, 'getServiceLocator')) {
            $container = $container->getServiceLocator() ?: $container;
        }

        return $this($container, LoggerInterface::class);
    }
114923
public function run(Container $container)
    {
        if ($this->description && $this->withoutOverlapping && ! $this->mutex->create($this)) {
            return;
        }

        register_shutdown_function(function ()
        {
            $this->removeMutex();
        });

        parent::callBeforeCallbacks($container);

        try {
            $response = $container->call($this->callback, $this->parameters);
        }
        finally {
            $this->removeMutex();

            parent::callAfterCallbacks($container);
        }

        return $response;
    }
340977
private function addDockerFacade(DependencyContainerInterface $container): DependencyContainerInterface
    {
        $container[self::DOCKER_FACADE] = function(DependencyContainerInterface $container) {
            return $container->getLocator()->dockerClient()->facade();
        };

        return $container;
    }
689863
public function setContainer(ContainerInterface $container)
    {
        $this->container = $container;
        $this->container->delegate(
            new ReflectionContainer()
        );
        $this->container->add(self::class, $this);
        self::setInstance($this);
    }
679563
public static function initContainer($container)
    {
        if ($container instanceof \Pimple\Container) {
            static::$container = $container;
            static::$logger = static::$container
                ->offsetGet(\oat\oatbox\log\LoggerService::SERVICE_ID)
                ->getLogger();
        }
    }
233982
public static function get(ContainerInterface $container) {
    $test_mode = $container
      ->get('config.factory')
      ->get('acm.connector')
      ->get('test_mode');

    if ($test_mode) {
      return $container->get('acm.test_agent_api');
    }

    return $container->get('acm.agent_api');
  }
170451
public function call(callable $container = null)
    {
        $this->action = $this->buildCallable($this->action, $container);

        if ($this->strategy === null) {
            return call_user_func_array($this->action, array_merge($this->defaults, $this->params));
        }

        if (!is_object($this->strategy)) {
            if ($container === null) {
                   $this->strategy = new $this->strategy;
            } else $this->strategy = $container($this->strategy);
        }

        return $this->callWithStrategy();
    }
1877
public function providePersistenceLayerDependencies(Container $container): Container
    {
        $container = parent::providePersistenceLayerDependencies($container);
        $container = $this->addProductListPropelQuery($container);

        return $container;
    }
617552
public function run(Container $container)
    {
        if ((! $this->ignoreMutex) && $this->description && $this->withoutOverlapping && (! $this->setMutex())) {
            return;
        }

        $this->runCommandInForeground($container);

        return $this->exitcode;
    }
365368
public function container($container = null)
    {
        if (is_null($container)) {
            return $this->factory->getContainer();
        }
        else {
            $this->factory->share($name, $handler);
            return null;
        }
    }
1175510
public function pause()
    {
        $deferred = new Deferred();

        if (! $this->speaking) {
            $deferred->reject(new \Exception('Audio must be playing to pause it.'));

            return $deferred->promise();
        }

        $this->isPaused = true;
        $deferred->resolve();

        return $deferred->promise();
    }
628333
public function getId($service): ?string
    {
        if ($this->serviceContainer === $service) {
            return 'service_container';
        }

        if (null === $id = ($this->getServiceId)($service)) {
            return null;
        }

        if ($this->serviceContainer->has($id) || $this->reversibleLocator->has($id)) {
            return $id;
        }

        return null;
    }
790584
public static function getInstance(Container $container = null)
    {
        if (null === self::$instance) {
            self::$instance = new Core($container);
        }
        return self::$instance;
    }