Start.
@param  string $key
@return void
@throws Oppa\Exception\InvalidKeyException
323962
public function start(string $key): void
    {
        $start = microtime(true);
        switch ($key) {
            case 'connection':
                $this->profiles[$key] = [
                    'start' => $start, 'end' => 0.00, 'time' => 0.00
                ];
                break;
            case 'query':
                $i = $this->queryCount;
                if (isset($this->profiles[$key][$i])) {
                    $this->profiles[$key][$i] += [
                        'start' => $start, 'end' => 0.00, 'time' => 0.00
                    ];
                }
                break;
            default:
                throw new InvalidKeyException("Unimplemented key '{$key}' given, available keys are"
                    ." 'connection,query' only!");
        }
    }
239644
public function setKey($key)
    {
        $this->key = $key;
        $this->driver->setNamespace($this->key);
    }
1280794
public function delete($key)
    {
        $filename = $this->getKeyCode($key);
        $this->memcacheObj->delete($filename);
    }
395924
public function start($path)
    {
        if (is_file($path)) {
            $this->setSchemaFromPath($path);

            return;
        }

        $this->setSchemaFromString($path);
    }
260747
public function start()
    {
        declare (ticks = 1);
        pcntl_signal(SIGINT, SIG_IGN, true);
        
        if (!$pipes = stream_socket_pair(STREAM_PF_UNIX, STREAM_SOCK_STREAM, STREAM_IPPROTO_IP)) {
            throw new \RuntimeException('Failed to create socket pair');
        }
        
        $pid = pcntl_fork();
        
        if ($pid > 0) {
            if (function_exists('setproctitle')) {
                setproctitle('boris (master)');
            }
            
            fclose($pipes[0]);
            $client = new ReadlineClient($pipes[1]);
            $client->start($this->_prompt, $this->_historyFile);
        } elseif ($pid < 0) {
            throw new \RuntimeException('Failed to fork child process');
        } else {
            if (function_exists('setproctitle')) {
                setproctitle('boris (worker)');
            }
            
            fclose($pipes[1]);
            $worker = new EvalWorker($pipes[0]);
            $worker->setLocal($this->_exports);
            $worker->setStartHooks($this->_startHooks);
            $worker->setFailureHooks($this->_failureHooks);
            $worker->setInspector($this->_inspector);
            $worker->start();
        }
    }
918027
protected function setKey($key, $value)
    {
        if ($key == $this->_keyName) {
            $this->_keyValue = $value;
            $this->_key['value'] = $value;
        }
    }
1141916
public function delete($key)
    {
		if (! $key || ! is_string($key)) {
			throw new InvalidArgumentException('Invalid cache key');
		}

		$transientKey = $this->generateTransientKey($key);
		delete_transient($transientKey);
	}
805728
protected function addKey(string $key) : void
    {
        if (!$this->keyStore->isValidKey($key)) {
            throw new DumpException("The key \"{$key}\" has already been defined previously.");
        }

        $this->keyStore->addKey($key);
    }
451030
protected function assertKey($key): void
    {
        if (!is_string($key)) {
            $type = (is_object($key) ? get_class($key) . ' ' : '') . gettype($key);
            throw new InvalidArgumentException("Expected key to be a string, not $type");
        }

        if ($key === '' || preg_match('~[{}()/\\\\@:]~', $key)) {
            throw new InvalidArgumentException("Invalid key '$key'");
        }
    }
1030155
public function setKey($key)
    {
        $this->hash = null;

        if (empty($key)) {
            $this->key = null;
            return;
        }

        $this->key = (string) $key;
        $this->hash = $this->makeHash($key);
    }
295683
public void start()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "start");

    if(!started)
    {
      started = true;
      if(keyGroup != null)
        keyGroup.startMember();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "start");
  }
846421
public static function start($key = null)
    {
        // Add new item
        $key = self::add($key, [
            'start' => microtime(true),
        ]);

        // Set current item
        self::$currentItem = $key;

        // Add to running items
        self::$runningItems[$key] = true;

        return $key;
    }
261809
public function has_started($key)
  {
    if ( isset($this->measures[$key]) ){
      return $this->measures[$key]['start'] > 0;
    }
    return false;
  }
1119860
public function start($max = null)
    {
        $this->max = (int) $max;
        $this->progress->start($this->output, $max);
    }
71743
public function post($key = null)
    {
        if ($key) {

            if (isset($_POST[$key])) {
                return $_POST[$key];
            }

            throw new \InvalidArgumentException(sprintf(
                '%s ist not a valid key for $_POST', $key
            ));

        }

        return $_POST;
    }
146285
public function remove($key) {
        $key = $this->formatKey($key);
        array_remove($this->headers, $key);
    }
1171419
public function start($command)
    {
        $this->startWorkers($command);
        while ($this->isWorking()) {
            $worker = $this->getAvailableWorker();

            if ($worker && ! empty($this->pending)) {
                $worker->run(array_shift($this->pending));
            }

            $this->broker->read();
        }
    }