Determine the class that implements the type.

@param Identifier $identifier
@return string Class name
199666
protected static function _determineImplClass(Identifier $identifier): string
    {
        switch ($identifier->typeClass()) {
            case Identifier::CLASS_UNIVERSAL:
                return self::_determineUniversalImplClass($identifier->intTag());
            case Identifier::CLASS_CONTEXT_SPECIFIC:
                return ContextSpecificType::class;
            case Identifier::CLASS_APPLICATION:
                return ApplicationType::class;
            case Identifier::CLASS_PRIVATE:
                return PrivateType::class;
        }
        throw new \UnexpectedValueException(
            sprintf("%s %d not implemented.",
                Identifier::classToName($identifier->typeClass()),
                $identifier->tag()));
    }
723257
public function getParameterBag($identifier)
    {
        if (isset($this->parameterBags[$identifier])) {
            return $this->parameterBags[$identifier];
        }

        return null;
    }
629435
protected function _findIdentity($identifier)
    {
        $fields = $this->getConfig('fields.' . self::CREDENTIAL_USERNAME);
        $conditions = [];
        foreach ((array)$fields as $field) {
            $conditions[$field] = $identifier;
        }

        return $this->getResolver()->find($conditions, ResolverInterface::TYPE_OR);
    }
1193935
public static function getAddonByIdentifier(string $identifier)
    {
        foreach (self::getAddons() as $addon) {
            if ($addon->getIdentifier() == $identifier) {
                return $addon;
            }
        }
        
        return null;
    }
144008
public function getJobFromId($identifier)
    {
        return array_key_exists($identifier, $this->identifierToId)
            ? $this->jobs[$identifier]
            : null;
    }
929037
public function getType($identifier)
    {
        return isset($this->types[$identifier])? $this->types[$identifier]: null;
    }
430251
public function findClass(AnServiceIdentifier $identifier)
    {
        $classname = 'An'.ucfirst($identifier->package).AnInflector::implode($identifier->path).ucfirst($identifier->name);

        if (!class_exists($classname)) {
            $classname = AnServiceClass::findDefaultClass($identifier);

            if (!$classname) {
                // use default class instead
                $classname = 'An'.ucfirst($identifier->package).AnInflector::implode($identifier->path).'Default';

                if (!class_exists($classname)) {
                    $classname = false;
                }
            }
        }

        return $classname;
    }
485231
public function getByIdentifier(Identifier $identifier)
    {
        $className = $identifier->class->getName();
        $mapId     = $identifier->getSerialized();

        return $this->identityMap[$className][$mapId];
    }
916743
public function getEntityByIdentifier($identifier)
    {
        $found_entities = $this->filter(
            function (EntityInterface $entity) use ($identifier) {
                return $entity->getIdentifier() === $identifier;
            }
        );

        return $found_entities->getFirst();
    }
526698
protected function find($identifiers, $targetClass)
    {
        if ($identifiers instanceof $targetClass) {
            return $identifiers;
        }

        if ($this->isNullIdentifier($identifiers)) {
            return null;
        }

        return $this->objectManager->find($targetClass, $identifiers);
    }
997142
public function identifier($identifier = null)
    {
        if (null === $identifier) {
            return $this->identifier;
        }

        $this->identifier = $identifier;
        return $this;
    }
488848
public function normalizeIdentifier($identifier)
    {
        foreach ($this->plugins as $id => $object) {
            if (strtolower($id) == strtolower($identifier)) {
                return $id;
            }
        }

        return $identifier;
    }
630282
public static function getAssertionIdentifier($identifier = null)
    {
        // Keep a registry of how many assertions were run
        // in this test suite, and in this test
        $methodName = static::$suite->getName();
        static::$assertionsInTest[$methodName] = isset(static::$assertionsInTest[$methodName])
            ? static::$assertionsInTest[$methodName]
            : -1;

        $name = $methodName.'-'.++static::$assertionsInTest[$methodName];
        $name = $identifier ? $name.': '.$identifier : $name;

        return $name;
    }
1311665
public static function getEntityIdentifier($identifier)
    {
        $identifier = AnService::getIdentifier($identifier);

        if (!$identifier->basepath) {
            $adapters = AnService::get('anahita:loader')->getAdapters();
            $basepath = pick($adapters[$identifier->type]->getBasePath(), ANPATH_BASE);
            $applications = array_flip(AnServiceIdentifier::getApplications());

            if (isset($applications[$basepath])) {
                $identifier->application = $applications[$basepath];
                $identifier->basepath = $basepath;
            }
        }

        return $identifier;
    }
1037986
public function hasIdentifier($identifier)
    {
        if(!$identifier instanceof ObjectIdentifierInterface) {
            $identifier = $this->getIdentifier($identifier);
        }

        return in_array((string) $identifier, $this->__identifier_list);
    }
552687
public function parseIdentifier(ObjectIdentifier $identifier)
    {
        $package = ucfirst($identifier->package);
        $path    = StringInflector::implode($identifier->path);
        $file    = ucfirst($identifier->name);
        $class   = $path.$file;

        $info = array(
            'class'      => $class,
            'package'    => $package,
            'path'       => $path,
            'file'       => $file,
        );

        return $info;
    }
684935
public function getParameterType($identifier)
    {
        return isset($this->parameterTypes[$identifier]) ? $this->parameterTypes[$identifier] : null;
    }