Template variable getter. Returns an array if there is something in the list

@return array
483010
public function getNoticeProductList()
    {
        if ($this->_aNoticeProductList === null) {
            if ($oUser = $this->getUser()) {
                $this->_aNoticeProductList = $oUser->getBasket('noticelist')->getArticles();
            }
        }

        return $this->_aNoticeProductList;
    }
616992
public function getIterator()
    {
        $array = $this->getArrayCopy();

        // Is the collection nested in the array?
        if (isset($this->collectionProperty)) {

            // Locate the collection in the response.
            $collectionFound = false;
            $property = NULL;
            foreach ((array) $this->collectionProperty as $property) {
                if (isset($array[$property])) {
                    $collectionFound = true;
                    break;
                }
            }

            if (!$collectionFound) {
                throw new \OutOfBoundsException('Collection not found in response');
            }

            $array = $array[$property];
        }

        // Build the collection.
        $collection = array();
        foreach ($array as $item) {
            $element = new $this->elementClass($item);
            $collection[(string) $element] = $element;
        }

        return new \ArrayObject($collection);
    }
266785
private function foreachVariable() {
    if ($this->currentType === T_LIST) {
      return $this->_list();
    }
    else {
      if ($this->currentType === '&') {
        return $this->writeVariable();
      }
      else {
        return $this->variable();
      }
    }
  }
1289737
public function getValueList()
    {

        //$list = $this->valueList;
        $list=[];
        if (isset($_POST[$this->requestName])) {
            foreach ($_POST[$this->requestName] as $value) {
                $list[] = trim($value);
            }
        }

        return $list;

    }
854857
public function getDefAsArray()
    {
        return array_replace(
            $this->element->getDefAsArray(),
            [
                'name'              => $this->getName(),
                'type'              => $this->getType(),
                'doctrineType'      => $this->getTypeDoctrine(),
                'serializerType'    => $this->getTypeSerializer()
            ],
            $this->getHashAnonymousHashRequired()
        );
    }
1281263
protected function getItems()
    {
        $list = $this->DataSource->getItems($this->pagesize * ($this->currentpage - 1), $this->getPageSize(), $this->sortf, $this->sortd);
        $this->pagerowscount = count($list);
        return is_array($list) ? $list : array();
    }
1317649
public static function getVariables()
    {
        // Suppress return by-ref
        $vars = [ 'env' => static::$env ];
        // needs to use a for loop, using `array_merge([], $GLOBALS);` left reference traces somehow
        foreach ($GLOBALS as $varName => $varValue) {
            $vars[$varName] = $varValue;
        }

        return $vars;
    }
1279043
public function get()
    {
        $list      = [];
        $i         = 0;
        $realLimit = $this->offset && $this->limit
            ? $this->offset + $this->limit
            : $this->limit;

        foreach ($this->getData() as &$rs) {
            if ($this->offset && $this->offset > $i) {
                $i++;
                continue;
            }

            if ($realLimit && $realLimit == $i) {
                break;
            }

            if (!$this->where) {
                $list[] = $this->convertItem($rs);
                $i++;
                continue;
            }

            if ($this->matchWhere($rs)) {
                $list[] = $this->convertItem($rs);
                $i++;
            }
        }

        return $list;
    }
1141635
public function getVary(): array
    {
        if (!$vary = $this->headers->get('Vary', null, false)) {
            return [];
        }

        $ret = [];
        foreach ($vary as $item) {
            $ret = array_merge($ret, preg_split('/[\s,]+/', $item));
        }

        return $ret;
    }
8135
public function getIterator()
    {
        $array = [];
        foreach (array_keys($this->imports) as $group) {
            $array[$group] = $this->offsetGet($group);
        }

        return new ArrayIterator($array);
    }
434062
public function getOr()
    {
        $or = array();
        
        
        if($this->request->get('!or')){
            foreach ($this->request->get('!or') as $key => $value) {
                if(is_array($value)){
                    foreach($value as $k => $v){
                        $or[] = array($key => $v);
                    }
                }else{
                    $or[] = array($key => $value);    
                }
                
            }

            $or = array("!or" => $or);
        }

        return $or;
    }
669552
protected function getVariables()
    {
        $reflection = new ReflectionClass($this);
        foreach ($reflection->getProperties(
            ReflectionProperty::IS_PROTECTED |
            ReflectionProperty::IS_PRIVATE |
            ReflectionProperty::IS_STATIC
        ) as $property) {
            $ignore[] = $property->name;
        }
        $values = [];
        foreach ($this as $prop => $value) {
            if (!in_array($prop, $ignore)) {
                if (is_object($value)) {
                    if (method_exists($value, 'jsonSerialize')) {
                        $value = $value->jsonSerialize();
                    } elseif (method_exists($value, 'getArrayCopy')) {
                        $value = $value->getArrayCopy();
                    }
                }
                $values[$prop] = $value;
            }
        }
        return $values;
    }
574187
function get()
    {
        $result = array();

        foreach ((array)$this->matches as $item) {
            if ($this->engine == 'pspell') {
                $word = $item[0];
            }
            else {
                $word = mb_substr($this->content, $item[1], $item[2], RCUBE_CHARSET);
            }

            if (is_array($item[4])) {
                $suggestions = $item[4];
            }
            else if (empty($item[4])) {
                $suggestions = array();
            }
            else {
                $suggestions = explode("\t", $item[4]);
            }

            $result[$word] = $suggestions;
        }

        return $result;
    }
168415
public function getSetters(): array
    {
        if (null !== $this->setters) {
            return $this->setters;
        }
        $skip            = [
            'addPropertyChangedListener'     => true,
            'setEntityCollectionAndNotify'   => true,
            'addToEntityCollectionAndNotify' => true,
            'setEntityAndNotify'             => true,
        ];
        $this->setters   = [];
        $reflectionClass = $this->getReflectionClass();
        foreach ($reflectionClass->getMethods(
            \ReflectionMethod::IS_PRIVATE | \ReflectionMethod::IS_PUBLIC
        ) as $method) {
            $methodName = $method->getName();
            if (isset($skip[$methodName])) {
                continue;
            }
            if (\ts\stringStartsWith($methodName, 'set')) {
                $this->setters[$this->getGetterForSetter($methodName)] = $methodName;
                continue;
            }
        }

        return $this->setters;
    }
317488
private function getValuesAsArray()
    {
        if ($this->value === null) {
            return is_array($this->defaultValue) 
                ? $this->defaultValue 
                : [ $this->defaultValue ];
        }
        return $this->value;
    }
474967
public function getVariables() 
	{
		if(isset($this->attributes['class'])) {
			$this->attributes['class'] = trim($this
			->attributes['class'].' form-control');
		} else {
			$this->attributes['class'] = 'form-control';
		}
		
		return array(
			'attributes' 	=> $this->attributes,
			'items'			=> $this->items,
			'selected'		=> $this->value);
	}
562099
protected function _getIterator()
    {
        $data = &$this->_referDataArrayReference();
        foreach ($data as $k => $v) {
            (!array_key_exists($k, $this->__mapedPropObjects))
                ?: $k = $this->__mapedPropObjects[$k];

            yield $k => $v;
        }
    }