Returns the reference dot delimited

@return string
543068
protected function getReferenceDotDelimited()
    {
        if (empty($this->referenceDotDelimited)) {
            $this->referenceDotDelimited = self::normalizeReference($this->getReference());
        }
        return $this->referenceDotDelimited;
    }
1332412
public function getRegexp()
    {
        $regexps = array();
        /** @var PrefixBasedResolverInterface $resolver */
        foreach ($this->resolvers as $resolver) {
            $regexp = preg_replace('/^\^/', '', substr($resolver->getRegexp(), 1, -1));
            if ($regexp !== '') {
                $regexps[] = $regexp;
            }
        }
        return '/^(' . implode('|', $regexps) . ')/';
    }
538169
public function getName()
    {
        $ref = new \ReflectionObject($this);
        $name = $ref->getNamespaceName();
        $name = rtrim($name, '\\');

        return str_replace('\\', '_', strtolower($name));
    }
563872
private function getDocumentExtensionConstant()
    {
        $retour = [];
        if (empty($this->const_docsExt)) {
            $constants = $this->getConstants();
            foreach ($constants as $key => $constant) {
                $pos = strpos($key, 'EXT_DOCS');
                if ($pos !== false) {
                    $retour[$key] = $constant;
                }
            }
            $this->const_docsExt = $retour;
        } else {
            $retour = $this->const_docsExt;
        }
        return $retour;
    }
376637
protected function getRegex()
    {

        if( !self::$regexDefault ) {
            self::$regexDefault = implode(
                '|',
                array_map(
                    function($value){
                        return "(?<=[a-z0-9]){$value}(?=[A-Z])";
                    },
                    array_flip( self::$operations )
                )
            );
            self::$regexDefault = "/".self::$regexDefault."/";
        }

        return self::$regexDefault;

    }
388495
public function getDescription(): string
    {
        if (!$this->minValue) {
            return __('must have a length lower than "%d"', $this->maxValue);
        }
        if (!$this->maxValue) {
            return __('must have a length greater than "%d"', $this->minValue);
        }
        if ($this->minValue === $this->maxValue) {
            return __('must have a length "%d"', $this->minValue);
        }
        return __('must have a length between "%d" and "%d"', $this->minValue, $this->maxValue);
    }
136895
public function getExtension() {
		$dotPos = strrpos($this->path, '.');
		
		if ($dotPos === false) {
			return;
		}
		
		return substr($this->path, $dotPos + 1);
	}
1040378
public function getRef()
    {
        if (is_null($this->ref)) {
            $tags = $this->tags;
            sort($tags);
            $this->ref = md5(implode('-', $tags));
        }
        return $this->ref;
    }
1130796
protected function get()
    {
        $c               = $this->lookAhead;
        $this->lookAhead = null;
        if ($c === null) {
            if ($this->inputIndex < $this->inputLength) {
                $c = $this->input[$this->inputIndex];
                $this->inputIndex += 1;
            } else {
                return;
            }
        }
        if ($c === "\r" || $c === "\n") {
            return "\n";
        }
        if (ord($c) < self::ORD_SPACE) {
            return ' ';
        }
        return $c;
    }
1359304
public function getAsText()
    {
        if ($this->codeDefinition) {
            return $this->codeDefinition->asText($this);
        } else {
            $s = "";
            foreach ($this->getChildren() as $child) {
                $s .= $child->getAsText();
            }
            return $s;
        }
    }
1319670
public function getCompiled()
    {
        if ($this->compiled === null) {
            $regexp = "/^";

            // Method(s)
            $methodIdx = 0;
            foreach($this->methods as $method) {
                $regexp .= "(?:" . strtoupper($method) . ")";
                if (($methodIdx + 1) < count($this->methods)) {
                    $regexp .= "|";
                }
                $methodIdx++;
            }

            // Separator
            $regexp .= "~";

            // Url
            $regexp .= str_replace('/', '\/', $this->match);

            $regexp .= "$/";

            $this->compiled = $regexp;
        }
        return $this->compiled;
    }
886768
protected function _referenceName()
    {
        $table = $this->_table;
        $name = namespaceSplit(get_class($table));
        $name = substr(end($name), 0, -5);
        if (empty($name)) {
            $name = $table->getTable() ?: $table->getAlias();
            $name = Inflector::camelize($name);
        }

        return $name;
    }
618497
public function getDisplayName()
    {
        if ($this->name !== '') {
            $result = $this->name;
        } else {
            $result = '';
            $string = trim($this->handle, '_-');
            $segments = preg_split('/[_-]+/', $string);
            foreach ($segments as $segment) {
                if ($segment !== '') {
                    $len = mb_strlen($segment);
                    if ($len === 1) {
                        $segment = mb_strtoupper($segment);
                    } else {
                        $segment = mb_strtoupper(mb_substr($segment, 0, 1)) . mb_substr($segment, 1);
                    }
                    if ($result === '') {
                        $result = $segment;
                    } else {
                        $result .= ' ' . $segment;
                    }
                }
            }
            if ($result === '') {
                $result = $this->handle;
            }
        }

        return $result;
    }
312395
public function getFormatted(): string
    {
        return $this->format(
            [
                $this->getTitle(),
                $this->getFirstName(),
                $this->format($this->middleNames),
                $this->getLastName(),
                $this->getSuffix(),
            ]
        );
    }
876162
public function toString()
    {
        if ($this->max !== -1) {
            return vsprintf('{length: %d <= x <= %d}', [
                $this->min,
                $this->max,
            ]);
        }

        return vsprintf('{length: %d <= x}', [
            $this->min,
        ]);
    }
213021
protected function _getReferenceMapNormalized()
    {
        $referenceMapNormalized = array();

        foreach ($this->_referenceMap as $rule => $map) {

            $referenceMapNormalized[$rule] = array();

            foreach ($map as $key => $value) {
                switch ($key) {

                    // normalize COLUMNS and REF_COLUMNS to arrays
                    case self::COLUMNS:
                    case self::REF_COLUMNS:
                        if (!is_array($value)) {
                            $referenceMapNormalized[$rule][$key] = array($value);
                        } else {
                            $referenceMapNormalized[$rule][$key] = $value;
                        }
                        break;

                    // other values are copied as-is
                    default:
                        $referenceMapNormalized[$rule][$key] = $value;
                        break;
                }
            }
        }

        return $referenceMapNormalized;
    }
700929
public function getPrevChar()
	{
		if( $this->direction == ">" )
			$this->pointer--;
		if( $this->pointer <= $this->count() &&  $this->pointer > 0 )
		{
			$this->direction = "<";
			$this->pointer--;
			$character = $this->buffer[$this->pointer];
		}
		return $character;
	}