NB: does *not* check for embedded refs, even when $this->doResolveEmbeddedReferences is true
@param string $stringIdentifier
@return bool
500226
public function isReference($stringIdentifier)
    {
        if (!is_string($stringIdentifier)) {
            return false;
        }

        foreach ($this->resolvers as $resolver) {
            if ($resolver->isReference($stringIdentifier)) {
                return true;
            }
        }

        return false;
    }
471392
function (identifier) {
            return isString(identifier) ? this.__hashIdentifierToName(this.stringToIdentifier(identifier)) :
                isInstanceOf(identifier, Identifier) ? identifier.value :
                    isInstanceOf(identifier, QualifiedIdentifier) ? identifier.column :
                        isInstanceOf(identifier, AliasedExpression) ? identifier.alias : identifier;
        }
54086
protected function isRef(&$value, $modify = true)
    {
        $matches = null;
        $result =
            is_string($value) &&
            preg_match($this->refPattern, $value, $matches);
        if ($result && $modify) {
            $value = $matches[1];
        }

        return $result;
    }
809488
protected function renderNodeName($externalIdentifier)
    {
        return Slug::create(($this->nodeNamePrefix !== null ? $this->nodeNamePrefix : uniqid()) . $externalIdentifier)->getValue();
    }
583924
public function validateReferenceable()
    {
        if ($this->uuidFieldName && !$this->referenceable && 'full' !== $this->versionable) {
            throw MappingException::notReferenceable($this->name, $this->uuidFieldName);
        }
    }
387349
protected function createParsedIdentifier(SchemaIdentifierInterface $identifier): ParserIdentifierInterface
    {
        return $this->factory->createParsedIdentifier($this->position, $identifier);
    }
1222333
protected function releaseToken($tokenIdentifier)
    {
        $filtered = array_filter($this->tokens, function ($val) use ($tokenIdentifier) {
            return $val['token'] === $tokenIdentifier;
        });
        $keys = array_keys($filtered);
        $this->tokens[$keys[0]]['available'] = true;
    }
1077573
public function offsetExists($identifier)
    {
        $keys   = $this->_parseIdentifier($identifier);
        $last   = count($keys)-1;
        $data   = &$this->_data;
        $result = false;

        foreach($keys as $index => $key)
        {
            if (!array_key_exists($key, $data)) {
                break;
            }

            if ($index < $last) {
                $data =& $data[$key];
            }
            else $result = true;
        }

        return $result;
    }
1028589
public void setIdentifierResolver(final Object identifierResolver) {
        if (identifierResolver instanceof IdentifierResolver) {
            this.identifierResolver = (IdentifierResolver) identifierResolver;
        } else if (identifierResolver instanceof String) {
            this.identifierResolver = new IdentifierResolver() {
                public String getIdentifierFor(String nodeName) {
                    return (String) identifierResolver;
                }
            };
        } else if (identifierResolver instanceof Closure) {
            final ObjectGraphBuilder self = this;
            this.identifierResolver = new IdentifierResolver() {
                public String getIdentifierFor(String nodeName) {
                    Closure cls = (Closure) identifierResolver;
                    cls.setDelegate(self);
                    return (String) cls.call(new Object[]{nodeName});
                }
            };
        } else {
            this.identifierResolver = new DefaultIdentifierResolver();
        }
    }
1193935
public static function getAddonByIdentifier(string $identifier)
    {
        foreach (self::getAddons() as $addon) {
            if ($addon->getIdentifier() == $identifier) {
                return $addon;
            }
        }
        
        return null;
    }
14201
protected function resolveModelAndIdentifier($model, $identifier)
    {
        $resolve = new ResolveComponentModelIdentifier($model, $identifier);

        return $this->getComponentDataResolver()->resolveComponentData($resolve);
    }
961076
public function has(string $entryIdentifier): bool
    {
        if ($this->frozen === true) {
            return isset($this->cacheEntryIdentifiers[$entryIdentifier]);
        }
        if ($entryIdentifier !== basename($entryIdentifier)) {
            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1282073034);
        }
        return !$this->isCacheFileExpired($this->cacheDirectory . $entryIdentifier . $this->cacheEntryFileExtension);
    }
205128
protected function isReference($data)
    {
        // is a reference object
        if (is_object($data) && $data instanceof ReferenceAbstract) {
            return $data;

        // is string and matches reference pattern
        } elseif (is_string($data)) {
            $pat = '/^(@|%)([^\s]+)\1$/';
            $mat = []; // placeholders

            if (preg_match($pat, $data, $mat)) {
                return $mat[1] === '@' ?
                    new ServiceReference($mat[2]) :
                    new ParameterReference($mat[2]);
            }

            // parameter resolver support
            if ($this->hasResolver() &&
                $this->getResolver()->hasReference($data)) {

                list($s, $e) = $this->paramter_pattern;
                $pat = '/^' . preg_quote($s) . '([^\s]+)' . preg_quote($e). '$/';
                if (preg_match($pat, $data, $mat)) {
                    return new ParameterReference($mat[1]);
                }
            }

            return false;

        // not a match
        } else {
            return false;
        }
    }
18272
public function has(string $entryIdentifier): bool
    {
        $success = false;
        apcu_fetch($this->identifierPrefix . 'entry_' . $entryIdentifier, $success);
        return $success;
    }
542863
public function getWrapped(string $entryIdentifier): string
    {
        if (!$this->isValidEntryIdentifier($entryIdentifier)) {
            throw new \InvalidArgumentException('"' . $entryIdentifier . '" is not a valid cache entry identifier.', 1233057752);
        }

        return $this->backend->get($entryIdentifier);
    }
1168325
public function remove(string $entryIdentifier): bool
    {
        if (!isset($this->entries[$entryIdentifier])) {
            return false;
        }
        unset($this->entries[$entryIdentifier]);
        foreach (array_keys($this->tagsAndEntries) as $tag) {
            if (isset($this->tagsAndEntries[$tag][$entryIdentifier])) {
                unset($this->tagsAndEntries[$tag][$entryIdentifier]);
            }
        }
        return true;
    }
417551
public function hasDescriptor($descriptor, $value = null)
    {
        $this->loadDescriptors();

        $exists = array_key_exists($descriptor, $this->descriptors);

        if (false === $exists) {
            return false;
        }

        if (null === $value) {
            return true;
        }

        $descriptorValue = $this->descriptors[$descriptor];

        // normalize
        if ($descriptorValue === 'true') {
            $descriptorValue = true;
        }
        if ($descriptorValue === 'false') {
            $descriptorValue = false;
        }

        if ($value === $descriptorValue) {
            return true;
        }

        return false;
    }