/** * Factory and/or returns template objects. * * @param string $path Full path to template file * @param \Foil\Engine $engine * @param string $className A custom template class name * @return \Foil\Contracts\TemplateInterface */ public function factory($path, Engine $engine, $className = null) { if (!is_string($path)) { throw new InvalidArgumentException('Template path must be in a string.'); } if (!$this->templates->offsetExists($path)) { $class = $this->getClass($className); $template = new $class($path, $this->sections, $engine, $this->command); $template instanceof Aliasable && $this->alias and $template->alias($this->alias); $this->templates[$path] = $template; } return $this->templates[$path]; }
/** * Factory a section instance (if it was not already factored) and return it. * * @param string $name Section name * @param int|bool $mode Section mode, one of the mode const * @param string $className Full qualified section class name * @return \Foil\Contracts\SectionInterface * @throws InvalidArgumentException */ public function factory($name, $mode = false, $className = null) { if (!is_string($name)) { throw new InvalidArgumentException('Section name must be in a string.'); } if (!$this->sections->offsetExists($name)) { $class = $this->getClass($className); $this->sections[$name] = new $class($mode, $this->defaultMode); } else { $merge = $mode === SectionInterface::MODE_REPLACE ? false : true; $this->sections[$name]->setMode($mode, $merge); } return $this->sections[$name]; }
protected function existsAccess($key) { if ($this->object->offsetExists($key)) { return true; } return $this->existsObject($key); }
/** * Determine if the given key exists in the provided array. * * @param \ArrayAccess|array $array * @param string|int $key * * @return bool */ public function arrExists($array, $key) { if ($array instanceof ArrayAccess) { return $array->offsetExists($key); } return array_key_exists($key, $array); }
/** * Conditionally replace node value with new one * * @param string $key * @param string|integer|float|boolean $oldValue * @param mixed $newValue * * @return $this */ public function replaceValue($key, $oldValue, $newValue) { if ($this->array->offsetExists($key) && $oldValue === $this->array->offsetExists($key)) { $this->array->offsetSet($key, $newValue); } return $this; }
/** * Converts instance of \ArrayAccess to key => value array entry * * @param \ArrayAccess $object * * @return array|null * @throws \Prophecy\Exception\InvalidArgumentException */ private function convertArrayAccessToEntry(\ArrayAccess $object) { if (!$this->key instanceof ExactValueToken) { throw new InvalidArgumentException(sprintf('You can only use exact value tokens to match key of ArrayAccess object' . PHP_EOL . 'But you used `%s`.', $this->key)); } $key = $this->key->getValue(); return $object->offsetExists($key) ? array($key => $object[$key]) : array(); }
/** * @param \ArrayAccess $keyvalue * * @return boolean */ public function check(\ArrayAccess $keyvalue) { foreach ($this as $key => $value) { if (!($keyvalue->offsetExists($key) && $keyvalue->offsetGet($key) === $value)) { return false; } } return true; }
/** * @inheritdoc */ public function supply($section, $default = '') { if ($this->sections->offsetExists($section)) { return $this->sections[$section]->content(); } while (is_callable($default)) { $default = $default($section, $this); } return is_string($default) ? $default : ''; }
/** * Simple test comment. * * FANOUT := 4 * CALLS := 7 * * @param ArrayAccess $items The input items. * @param integer $index The requested index. * * @return MyObjectItem * @throws OutOfRangeException For invalid index values. * @throws InvalidArgumentException For invalid index values. */ function getItemAt(ArrayAccess $items, $index) { if (is_int($index) === false) { throw new InvalidArgumentException('Error'); } if (!$items->offsetExists($index)) { throw new OutOfRangeException('Error...'); } $data = $items->offsetGet($index); if (is_array($data)) { return new MyObjectItem(array_keys($data), array_values($data)); } return MyObjectItem::getDefault(); }
/** * Returns the content to render * * @param Request $request * @param Response $response * @param null|callable $next * @return null|Response */ public function dispatch(Request $request, Response $response, callable $next = null) : Response { // On GET requests that are not comming from PRG, just return the template if ($request->getMethod() === 'GET' && !$this->session->offsetExists(self::PRG_DATA)) { return $this->createTemplateResponse($request); } // On POST requests, get request data, store it in the session, and redirect to sel if ($request->getMethod() === 'POST') { $params = $request->getParsedBody(); $this->session->offsetSet(self::PRG_DATA, $params); return new RedirectResponse($request->getUri()); } // On a GET request that contains data, process the data and clear it from session $params = $this->session->offsetGet(self::PRG_DATA); $this->session->offsetUnset(self::PRG_DATA); $filter = $this->contactFilter; $filter->setData($params); if (!$filter->isValid()) { return $this->createTemplateResponse($request, ['errors' => $filter->getMessages(), 'currentData' => $params]); } // If the form is valid, send the email $result = $this->contactService->send($filter->getValues()); return $this->createTemplateResponse($request, $result ? ['success' => true] : ['errors' => []]); }
/** * @param \ArrayAccess $flagedObject * @param array $layout * @return array */ protected function getLayoutOptions(\ArrayAccess $flagedObject, array $layout) { $result = array(); foreach ($layout as $flag => $options) { if ($flagedObject->offsetExists($flag)) { $value = $flagedObject->offsetGet($flag); $value = (string) $value; if (isset($options[$value])) { $result += $options[$value]; } } } foreach ($this->layoutCallback as $callback) { $result = $callback($flagedObject, $result); } return $result; }
private function mergeTableData() { $keyValue = $this->getKeyValue(); // Nothing to do if setTableData() has not been called if ($this->arr === NULL) { return; } // Mark record as modified if we are a new record if (!$this->arr->offsetExists($keyValue)) { $this->state = self::DIRTY; return; } // DB fields are transfered into the object storage. Record state // is unchanged and existing values are retained. foreach ($this->arr->offsetGet($keyValue) as $key => $value) { if (!$this->data->offsetExists($key)) { $this->data->offsetSet($key, $value); } } }
/** * @see \ArrayAccess::offsetExists() */ public function offsetExists($offset) { return $this->metadata->offsetExists($offset); }
/** * Retrieve a single key from an array. If the key does not exist in the * array, the default value will be returned instead. * * // Get the value "username" from $_POST, if it exists * $username = Arr::get($_POST, 'username'); * * // Get the value "sorting" from $_GET, if it exists * $sorting = Arr::get($_GET, 'sorting'); * * @param array|\ArrayAccess $array array to extract from * @param string $key key name * @param mixed $default default value * @return mixed */ public static function get($array, $key, $default = NULL) { if ($array instanceof \ArrayObject) { // This is a workaround for inconsistent implementation of isset between PHP and HHVM // See https://github.com/facebook/hhvm/issues/3437 return $array->offsetExists($key) ? $array->offsetGet($key) : $default; } else { return isset($array[$key]) ? $array[$key] : $default; } }
/** * @param \Prophecy\Argument\Token\ExactValueToken $key * @param \Prophecy\Argument\Token\TokenInterface $value * @param \ArrayAccess $object */ function it_does_not_score_array_accessible_object_if_key_and_value_tokens_do_not_score_same_entry($key, $value, $object) { $object->offsetExists('key')->willReturn(true); $object->offsetGet('key')->willReturn('value'); $key->getValue()->willReturn('key'); $value->scoreArgument('value')->willReturn(false); $key->scoreArgument('key')->willReturn(true); $this->scoreArgument($object)->shouldBe(false); }
/** * Checks if a section was already factored. * * @param string $name * @return bool */ public function has($name) { return $this->sections->offsetExists($name); }
/** * @inheritdoc * * This implementation detects the specified offset in this context or any ancestor contexts. */ public function offsetExists($offset) { return parent::offsetExists($offset) || !is_null($this->parent) && $this->parent->offsetExists($offset); }
/** * Simple test comment. * * FANOUT := 4 * CALLS := 7 * * @param ArrayAccess $items The input items. * @param integer $index The requested index. * * @return MyObjectItem * @throws DomainException For invalid index values. * @throws InvalidArgumentException For invalid index values. */ public function getItemAt(ArrayAccess $items, $index) { if (is_int($index) === false) { throw new DomainException('Error'); } if (!$items->offsetExists($index)) { throw new OutOfBoundsException('Error...'); } $data = $items->offsetGet($index); if (is_array($data)) { return new MyObjectItem(array_keys($data), array_values($data)); } return MyObjectItemCollection::getDefault(); }
/** * Check if a given timer is active. * * @param TimerInterface $timer The timer to check. * * @return boolean True if the timer is still enqueued for execution. */ public function isTimerActive(TimerInterface $timer) { return $this->timers->offsetExists($timer); }
/** * @param ArrayAccess $item * @param string $property_or_method * @param mixed $property_value * @param string $comparison_operator * @param array $method_arguments * @return bool */ protected function item_matches_condition(ArrayAccess $item, $property_or_method, $property_value, $comparison_operator, array $method_arguments = null) { if ($item->offsetExists($property_or_method)) { if ($this->compare($item->offsetGet($property_or_method), $property_value, $comparison_operator)) { return true; } } else { if (method_exists($item, $property_or_method)) { $method_result = $method_arguments ? call_user_func_array(array($item, $property_or_method), $method_arguments) : $item->{$property_or_method}(); if ($this->compare($method_result, $property_value, $comparison_operator)) { return true; } } } return false; }