@param string $fqcn
@param string $fqin

@return bool
977672
private function isImplementing($fqcn, $fqin)
    {
        $interfaces = class_implements($fqcn, true);
        return isset($interfaces[$fqin]);
    }
876098
public function getMapper($fqcn)
    {
        if (!isset($this->mappers[$fqcn])) {
            $this->mappers[$fqcn] = $this->createMapper($fqcn);
        }

        return $this->mappers[$fqcn];
    }
807640
public function getHasSingularInterfaceFqnForEntity(
        string $entityFqn
    ): string {
        try {
            $interfaceNamespace = $this->getInterfacesNamespaceForEntity($entityFqn);

            return $interfaceNamespace . '\\Has' . ucfirst($entityFqn::getDoctrineStaticMeta()->getSingular())
                   . 'Interface';
        } catch (\Exception $e) {
            throw new DoctrineStaticMetaException(
                'Exception in ' . __METHOD__ . ': ' . $e->getMessage(),
                $e->getCode(),
                $e
            );
        }
    }
1101875
public function createEmptyDtoFromEntityFqn(string $entityFqn)
    {
        $dtoFqn = $this->namespaceHelper->getEntityDtoFqnFromEntityFqn($entityFqn);

        $dto = new $dtoFqn();
        $this->resetCreationTransaction();
        $this->createdDtos[$dtoFqn] = $dto;
        $this->setId($dto);
        $this->addRequiredItemsToDto($dto);
        $this->resetCreationTransaction();

        return $dto;
    }
58113
public function getHasPluralInterfaceFqnForEntity(
        string $entityFqn
    ): string {
        $interfaceNamespace = $this->getInterfacesNamespaceForEntity($entityFqn);

        return $interfaceNamespace . '\\Has' . ucfirst($entityFqn::getDoctrineStaticMeta()->getPlural()) . 'Interface';
    }
294840
public function removeDefinition(string $fqn)
    {
        $parts = $this->splitFqn($fqn);
        $this->removeIndexedDefinition(0, $parts, $this->definitions, $this->definitions);

        unset($this->references[$fqn]);
    }
270503
public function getNamespaceRootToDirectoryFromFqn(string $fqn, string $directory): ?string
    {
        $strPos = \strrpos(
            $fqn,
            $directory
        );
        if (false !== $strPos) {
            return $this->tidy(\substr($fqn, 0, $strPos + \strlen($directory)));
        }

        return null;
    }
962349
function isEntity(string $classFQCN) : bool
    {
        if ( ! class_exists($classFQCN)) {

            throw new ClassNotFoundException(sprintf('Given class FQCN "%s" does not exist.', $classFQCN));
        }

        if ( ! is_object($classFQCN)) {

            throw new EntityNotFoundException(sprintf('Given class "%s" is not a Doctrine Entity.', $classFQCN));
        }

        return ! $this->getObjectManager()
                      ->getMetadataFactory()
                      ->isTransient(ClassUtils::getClass($classFQCN));
    }
817709
public function getDefinition(string $fqn, bool $globalFallback = false)
    {
        foreach ($this->getIndexes() as $index) {
            if ($def = $index->getDefinition($fqn, $globalFallback)) {
                return $def;
            }
        }
    }
23608
private function registerAutoload($fqcn, $path)
    {
        $namespace = str_replace(strrchr($fqcn, '\\'), '', $fqcn);
        $psr0 = str_replace('\\', DIRECTORY_SEPARATOR, $namespace);

        // A part of the namespace should match a part of the path (PSR-0 standard)
        if (substr_count($path, $psr0) == 0) {
            throw new \RuntimeException('Boomgo annotation parser support only PSR-0 project structure');
        }

        $baseDirectory = str_replace($psr0, '', dirname($path));
        $partNamespace = explode('\\', $namespace);
        $baseNamespace = $partNamespace[0];

        spl_autoload_register(function($class) use ($baseNamespace, $baseDirectory) {
            if (0 === strpos($class, $baseNamespace)) {
                $path = $baseDirectory.str_replace('\\', DIRECTORY_SEPARATOR, $class).'.php';
                if (!stream_resolve_include_path($path)) {
                    return false;
                }
                require_once $path;

                return true;
            }
        });
    }
555034
private function getEventExchangeName($messageFqcn)
    {
        $messageFqcn = trim($messageFqcn, '\\');
        $pos = strrpos($messageFqcn, '\\');
        if ($pos !== false) {
            $messageFqcn = substr_replace($messageFqcn, ':', $pos, 1);
        }
        return str_replace('\\', '.', $messageFqcn);
    }
272668
public function getReflectionClass($classFQN)
    {
        try {
            $reflectionClass = new \ReflectionClass($classFQN);
        } catch (\ReflectionException $re) {
            return new CoverFishMessageError(CoverFishMessageError::PHPUNIT_REFLECTION_CLASS_NOT_FOUND, $classFQN);
        }

        return $reflectionClass;
    }
732829
public function cropSuffix(string $fqn, string $suffix): string
    {
        if ($suffix === \substr($fqn, -\strlen($suffix))) {
            return \substr($fqn, 0, -\strlen($suffix));
        }

        return $fqn;
    }
1033986
protected function buildProxy(string $fqcn): ProxyInterface
    {
        return ProxyGeneratorFactory::get($this->mockingStrategy)->get($fqcn);
    }
232063
public function getElementsByType($fqcn)
    {
        $elements = [];
        $content = $this->getContent();

        foreach ($content as $element) {
            if ($element instanceof $fqcn) {
                $elements[] = $element;
            }
        }

        return $elements;
    }
511961
public function getClassNameFromTable(Table $table, $fqcn = false)
    {
        $namespace = $table->getNamespace();
        $class = $table->getPhpName();

        return $this->declareClassNamespace($class, $namespace, true);
    }
1179775
protected function doBuild(string $fqcn): MockObject
    {
        return $this->generator->getMock(
            $fqcn,
            $methods = [],
            $arguments = [],
            $mockClassName = '',
            $callOriginalConstructor = false
        );
    }