Template variable getter. Returns reverse option blOrderDisWithoutReg

@return bool
766814
public function getShowNoRegOption()
    {
        if ($this->_blShowNoRegOpt === null) {
            $this->_blShowNoRegOpt = !\OxidEsales\Eshop\Core\Registry::getConfig()->getConfigParam('blOrderDisWithoutReg');
        }

        return $this->_blShowNoRegOpt;
    }
444375
public function getInnerIterator()
    {
        if (is_callable($this->inner)) {
            // callable
            $this->inner = call_user_func($this->inner);
        }

        if (is_array($this->inner)) {
            // array
            $this->inner = new \ArrayIterator($this->inner);
        } elseif ($this->inner instanceof \IteratorAggregate) {
            // IteratorAggregate
            while ($this->inner instanceof \IteratorAggregate) {
                $this->inner = $this->inner->getIterator();
            }
        }

        if (!$this->inner instanceof \Iterator) {
            throw new UnexpectedTypeException($this->inner, 'Iterator');
        }

        return $this->inner;
    }
213609
protected function GetReturnToLastStepURL()
    {
        $sLink = false;
        $oBackItem = $this->GetPreviousStep();
        if (!is_null($oBackItem)) {
            $sLink = $oBackItem->GetStepURL();
        }

        return $sLink;
    }
1202838
public function getOperator()
    {
        $returnValue = null;

        
        if(empty($this->arithmeticOperator)){
        	$property = new core_kernel_classes_Property(RulesRdf::PROPERTY_OPERATION_OPERATOR);
        	$this->arithmeticOperator = $this->getUniquePropertyValue($property);
        }
        $returnValue = $this->arithmeticOperator;
        

        return $returnValue;
    }
1328715
public function reverse()
    {
        $result = [];

        foreach ($this->components as $i => $component) {
            $result[$i] = $component * -1;
        }

        return new static($result);
    }
564896
public function reverse()
	{
		$length = $this->length();
		$reversed = '';
		while ($length-- > 0) {
			$reversed .= mb_substr($this->string, $length, 1, mb_detect_encoding($this->string));
		}
		$this->string = $reversed;
		return $this;
	}
489455
public function get()
    {
        if ($this->isInteger()) {
            /** @noinspection PhpUndefinedMethodInspection */
            return $this->value['num']->get();
        }

        $num = intval(gmp_strval($this->value['num']->gmp()));
        $den = intval(gmp_strval($this->value['den']->gmp()));

        return $num/$den;
    }
802325
public function getLogicalOperator()
    {
        $returnValue = null;

        
         if(empty($this->logicalOperator)){
         	$property = new core_kernel_classes_Property(RulesRdf::PROPERTY_HASLOGICALOPERATOR);
			$this->logicalOperator = $this->getUniquePropertyValue($property);
         }
         $returnValue = $this->logicalOperator;
        

        return $returnValue;
    }
617547
public static function getCurrentProviderId()
    {
        try {
            $optionValue = Option::get(self::CURRENT_PROVIDER_OPTION_NAME);
        } catch (\Exception $e) {
            $optionValue = false;
        }
        return $optionValue === false ? DefaultProvider::ID : $optionValue;
    }
1350956
public function popRight(): ?string
    {
        $ret = $this->handle->rPop($this->name);
        return $ret === false ? null : $ret;
    }
74882
public function getIterator()
    {
        $iter = parent::getIterator();

        // sorting support
        if ($this->sortby) {
            $desc = ($this->sortby_db[0] == '-');
            $order = ltrim($this->sortby_db, '-');
            $this->applySorting($iter, $order, $desc);
        }

        return $iter;
    }
1228511
public function getIsSingleIterator()
	{
		/**
		 * @var XPath2NodeIterator $iter
		 */
		$iter = $this->CloneInstance();
		// $iter->named = "Original";
		$part1 = $iter->MoveNext();
		if ( $part1 )
		{
			$part2 = ! $iter->MoveNext();
			if ( $part2 ) return true;
		}

		return false;
	}
222351
public function getIterator()
    {
        $aResult = array();
        $iStart  = ($this->itemsPerPage * ($this->page - 1));
        if ($iStart < 0) {
            throw new \OutOfBoundsException('Start index cant no be lower then 1');
        }
        try {
            $iRestOfResults                    = ($this->itemsPerPage - 1);
            $mFirstValues                      = $this->collection->seek($iStart);
            $aResult[$this->collection->key()] = $mFirstValues;
            while ($iRestOfResults > 0) {
                $mValue = $this->collection->scNext();
                if ($mValue === AbstractCollection::NOT_SET_FLAG) {
                    throw new \OutOfBoundsException();
                }
                $aResult[$this->collection->key()] = $mValue;
                $iRestOfResults--;
            }

        } catch (\OutOfBoundsException $oException) {
            // do nothing, this exception is not critical
        }
        $sClassName = get_class($this->collection);

        return new $sClassName($aResult);
    }
19736
protected function getIterator()
    {
        if ($this->iterator === null && $this->isExists()) {
            $dirIterator = new DirectoryIterator($this->getPathname());
            $this->iterator = new CallbackFilterIterator($dirIterator, function ($current, $key, $iterator) {
                return !$iterator->isDot();
            });
        }

        return $this->iterator;
    }
1126959
public static function getCaller()
    {
        $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
        if (isset($backtrace[2])) {
            $caller = '';
            if (isset($backtrace[2]['class'])) {
                $caller = $backtrace[2]['class'] . $backtrace[2]['type'];
            }
            $caller .= $backtrace[2]['function'];
            return $caller;
        }
        return '{null}';
    }
245645
private function getopt()
    {

        // Reset option argument
        $this->optarg = null;
        
        // Check for index validity
        if ($this->optind >= $this->argc) {
            return -1;
        }

        // Get a copy of the current option to examine
        $arg = $this->argv[$this->optind];

        if ($this->isLongOption($arg)) {
            return $this->parseLongOption($arg);
        }

        if ($this->isShortOption($arg)) {
            return $this->parseShortOption($arg);
        }

        // If it's not an option, it's an argument,
        // so we stop parsing at the first non-option string
        // and $this->optind points to the first argument

        // Default: no options found
        return -1;
    }
410719
public function getBinary()
    {
        $result  = $this->getIdentifier();
        $result .= $this->createLengthPart();
        $result .= $this->getEncodedValue();

        return $result;
    }