/**
* Returns required option value
*
* @param string $optionName
* @return mixed
*/
public function getOption($optionName)
{
if ($this->_options instanceof ArrayObject && $this->_options->offsetExists($optionName)) {
return $this->_options->offsetGet($optionName);
}
return NULL;
}
/**
* Test if has datas with $uid key
* @param mixed $uid
* @return boolean
*/
public function has($uid)
{
if (null === $this->session) {
return false;
}
return $this->session->offsetExists($uid);
}
/**
* @return mixed
* @param string $name
* @param mixed $defaultValue
*/
public function getArgument($name, $defaultValue = null)
{
if ($this->arguments->offsetExists($name)) {
return $this->arguments->offsetGet($name);
}
return $defaultValue;
}
public function load($name, $throw_exception = true)
{
if ($throw_exception && !$this->arrayObject->offsetExists($name)) {
throw new PluginManagerException(sprintf("Plugin %s not found failure", $name));
}
return $this;
}
public function getParam($name)
{
if (!$this->storage->offsetExists($name)) {
return null;
}
return $this->storage->offsetGet($name);
}
/**
* Obtem o caminho de um diretorio
* @param string $index
* @return boolean
*/
public function getDirectory($index)
{
if ($this->paths->offsetExists($index)) {
return $this->paths->offsetGet($index);
}
return false;
}
/**
* Obtem um param enviado via Request Http
* @param int|string $index
* @return mixed|boolean
*/
public function getParam($index)
{
if ($this->params->offsetExists($index)) {
return $this->params->offsetGet($index);
}
return false;
}
/**
* Get component data
*
* @param string $name
* @return array
* @throws LocalizedException
*/
public function getComponentData($name)
{
if (!$this->componentData->offsetExists($name)) {
throw new LocalizedException(new Phrase('The requested component ("' . $name . '") is not found. ' . 'Before using, you must add the implementation.'));
}
return (array) $this->componentData->offsetGet($name);
}
function testArrayObject()
{
$obj = new ArrayObject();
$obj[2] = "something";
$this->assertTrue($obj->offsetExists(2));
$this->assertFalse($obj->offsetExists('2'));
$this->assertFalse($obj->offsetExists(1));
}
/**
* returns field descriptor
*
* @throws \VisioCrudModeler\Exception\FieldNotFound
* @return DbFieldDescriptor
*/
public function getFieldDescriptor($fieldName)
{
if (!array_key_exists($fieldName, $this->definition['fields'])) {
throw new FieldNotFound("field '" . $fieldName . "' not found in '" . $this->getName() . "'");
}
if (!$this->fieldDescriptors->offsetExists($fieldName)) {
$this->fieldDescriptors->offsetSet($fieldName, new WebFieldDescriptor($this, $this->definition['fields'][$fieldName]));
}
return $this->fieldDescriptors->offsetGet($fieldName);
}
/**
* Check the object cache see if the data has already been retrieved
*
* This cache is only persisted throughout a request
*
* @param KCommandContext $context
*
* @return void
*/
protected function _beforeRepositoryFetch(KCommandContext $context)
{
if ($this->_enable) {
$key = $this->_getCacheKey($context->query);
if (self::$_cache->offsetExists($key)) {
$context->data = self::$_cache->offsetGet($key);
return false;
}
}
}
/**
* @param string $index
* @param null|string $defaultValue
* @param bool $filtered If you trust foreign input introduced to your PHP code - set to FALSE!
*
* @return string
*/
public function get($index, $defaultValue = null, $filtered = true)
{
if ($this->data->offsetExists($index)) {
if ($filtered === true) {
// pretty high-level filtering here...
return self::filter($this->data->offsetGet($index));
}
return $this->data->offsetGet($index);
}
return $defaultValue;
}
/**
* Get Map to business or dao
* @param string $index
* @param array $map
*/
public function getMapTo($index, $to)
{
if ($this->maps->offsetExists($index)) {
$map = $this->maps->offsetGet($index);
if (in_array($to, array('db', 'object'))) {
return $map[$to];
}
return FALSE;
} else {
return FALSE;
}
}
/**
* Process the registration of one service.
*
* @param string $className The class name of the service
*
* @throws \Subbly\Api\Exception If class name does not exists
* @throws \Subbly\Api\Exception If the class does not implement \Subbly\Api\Service\Service
* @throws \Subbly\Api\Exception If service name is already register
*/
public function registerService($className)
{
if (!class_exists($className)) {
throw new Exception(sprintf(Exception::SERVICE_CLASS_NOT_EXISTS, $className));
}
$service = new $className($this);
if (!$service instanceof Service) {
throw new Exception(sprintf(Exception::NOT_A_SERVICE, $className));
}
if ($this->services->offsetExists($service->name())) {
throw new Exception(sprintf(Exception::SERVICE_ALREADY_EXISTS, $service->name()));
}
$this->services->offsetSet($service->name(), $service);
}
/**
* Get an item from an array using "dot" notation.
*
* @param string|integer $index The index or identifier.
* @param mixed $default
*
* @return mixed|null
*/
public static function get($index, $default = null)
{
if (self::$battery->offsetExists($index)) {
return self::$battery->offsetGet($index);
}
$array = self::$battery->getArrayCopy();
foreach ((array) explode('.', $index) as $segment) {
if (!is_array($array) || !array_key_exists($segment, $array)) {
return $default;
}
$array = $array[$segment];
}
return $array;
}
/**
* Return a synthetic table
*
* @param string $table_name table name
*
* @throws Exception\InvalidArgumentException if table name is not valid
*
* @return Table
*/
public function table($table_name)
{
if (!is_string($table_name)) {
throw new Exception\InvalidArgumentException(__METHOD__ . ": Table name must be a string");
}
if (!$this->localTableCache->offsetExists($table_name)) {
$tables = $this->metadata()->getTables();
if (!in_array($table_name, $tables)) {
throw new Exception\TableNotFoundException(__METHOD__ . ": Table {$table_name} is not found in database, if table exists please make sure cache is updated.");
}
$table = new Table($table_name, $this);
$this->localTableCache->offsetSet($table_name, $table);
}
return $this->localTableCache->offsetGet($table_name);
}
public function offsetExists($offset)
{
if (!isset($this->data)) {
$this->lazyInitialization();
}
return $this->data->offsetExists($offset);
}
public function offsetUnset($task)
{
$this->db->prepare($this->delete)->execute($task);
if (parent::offsetExists($task)) {
parent::offsetUnset($task);
}
}
/**
* Method to retrieve an element from the collection.
* @access public
* @throws Exception
* @return tx_crawler_domain_process
*/
public function offsetGet($index)
{
if (!parent::offsetExists($index)) {
throw new Exception('Index "' . var_export($index, true) . '" for tx_crawler_domain_process are not available');
}
return parent::offsetGet($index);
}
/**
* Returns the value from the header.
* If the value is empty, then this method returns an empty string
*
* @param String $aValue
* @return String
*/
public final function getValue($aKey)
{
if ($this->values->offsetExists($aKey)) {
return $this->values->offsetGet($aKey);
}
return "";
}
public function offsetExists($Index)
{
if ($Index === null) {
return false;
}
return parent::offsetExists($Index);
}
/**
* @param string $event
* @param \Closure $handler
* @param int $priority
*/
protected function addEventCallback($event, \Closure $handler, $priority)
{
if (!$this->callbacks->offsetExists($event)) {
$this->callbacks->offsetSet($event, new \Nano\Event\Queue());
}
$this->callbacks->offsetGet($event)->insert($handler, $priority);
}
/**
* Get a variable.
*
* @param string $name Variable name.
* @return callable
* @throws \Hoa\Math\Exception\UnknownVariable
*/
public function getVariable($name)
{
if (false === $this->_variables->offsetExists($name)) {
throw new Math\Exception\UnknownVariable('Variable %s does not exist.', 4, $name);
}
return $this->_variables[$name]($this);
}
public function offsetExists($offset)
{
if (is_null($this->modified)) {
$this->lazyInitialization();
}
return is_object($this->data) && $this->data->offsetExists($offset);
}
/**
* Loads the plugin instance of the given plugin name.
*
* @throws Enlight_Exception
* @param $name
* @return Enlight_Plugin_PluginCollection
*/
public function load($name)
{
if (!$this->plugins->offsetExists($name)) {
throw new Enlight_Exception('Plugin "' . $name . '" not found failure');
}
return $this;
}
/**
* @param ReflectionMethod $constructorReflection
* @param string $parentParams
* @param string $class
*
* @return array
*/
private function getUnifiedParams(\ReflectionMethod $constructorReflection, $parentParams, $class)
{
$unifiedParams = [];
// reflect on what params to pass, in which order
$params = $constructorReflection->getParameters();
foreach ($params as $param) {
/* @var $param \ReflectionParameter */
$name = $param->name;
$explicit = $this->params->offsetExists($class) && isset($this->params[$class][$name]);
if ($explicit) {
// use the explicit value for this class
$unifiedParams[$name] = $this->params[$class][$name];
continue;
} elseif (isset($parentParams[$name])) {
// use the implicit value for the parent class
$unifiedParams[$name] = $parentParams[$name];
continue;
} elseif ($param->isDefaultValueAvailable()) {
// use the external value from the constructor
$unifiedParams[$name] = $param->getDefaultValue();
continue;
}
// no value, use a null placeholder
$unifiedParams[$name] = null;
}
return $unifiedParams;
}
/**
* @param $key
* @param bool $default
* @return bool
*/
public function get($key, $default = false)
{
if (parent::offsetExists($key)) {
return parent::offsetGet($key);
}
return $default;
}
/**
* Obtem uma Rota a partir do indice
* @param string $index
* @return string|boolean
*/
public function get($index)
{
if ($this->resources instanceof \S9\Model\DAO) {
$oAdapter = $this->resources->getAdapter();
return $oAdapter->fetchRow($oAdapter->quoteInto("SELECT a.name AS 'ALIAS',\n r.module AS 'MODULE',\n r.controller AS 'CONTROLLER',\n r.action AS 'ACTION',\n r.params AS 'PARAMS',\n r.permission AS 'PERMISSION' \n FROM alias a, route r \n WHERE a.id = r.id_alias AND a.name = ?", strtolower($index)));
} else {
if ($this->resources instanceof \ArrayObject) {
if ($this->resources->offsetExists($index)) {
return $this->resources->offsetGet($index);
}
return false;
} else {
return false;
}
}
}
/**
* Gibt das Element der Liste zurück wenn es existiert
* @param mixed $index
* @throws InvalidArgumentException
*/
public function offsetGet($index)
{
if (!parent::offsetExists($index)) {
throw new Dragon_Application_Exception_System('missing record', array('index' => $index));
}
return parent::offsetGet($index);
}
/**
* Get a constant.
*
* @param string $name Constant name.
* @return mixed
* @throws \Hoa\Math\Exception\UnknownFunction
*/
public function getConstant($name)
{
if (false === $this->_constants->offsetExists($name)) {
throw new Math\Exception\UnknownConstant('Constant %s does not exist', 1, $name);
}
return $this->_constants[$name];
}