Returns the doctrine repository.

@return ObjectRepository
763120
public function getRepository()
    {
        if ($this->repository === null) {
            $this->repository = $this->entityManager->getRepository($this->entityName);
        }

        return $this->repository;
    }
1137861
public function getRepository($name = null)
    {
        // Resolve repository class name
        $repositoryName = $this->resolveRepositoryClassName($name);

        return new $repositoryName($this->getValidator(), $this->config);
    }
801111
public function getRepository($type)
    {
        try {
            $ldapObjectSchema = $this->getLdapObjectSchema($type);
            $repositoryClass = $ldapObjectSchema->getRepository();
            if (!class_exists($repositoryClass)) {
                throw new \RuntimeException(sprintf('Repository class "%s" not found.', $repositoryClass));
            }
            $repository = new $repositoryClass($ldapObjectSchema, $this->getConnection());
            if (!($repository instanceof LdapObjectRepository)) {
                throw new \RuntimeException('Your repository class must extend \LdapTools\Object\LdapObjectRepository.');
            }
        } catch (\Exception $e) {
            throw new \RuntimeException(sprintf('Unable to load Repository for type "%s": %s', $type, $e->getMessage()));
        } catch (\Throwable $e) {
            throw new \RuntimeException(sprintf('Unable to load Repository for type "%s": %s', $type, $e->getMessage()));
        }

        return $repository;
    }
322740
public function getParentRepository()
    {
        $parent = $this->getRepository()->getDescription()->getProperty('parent');
        $parent = $this->getIdentifier($parent->getParent());

        return AnDomain::getRepository($parent);
    }
1150449
public function getTermTaxonomyEntityRepository() 
    {
    	if(isset($this->er['TermTaxonomy'])) {
    		return $this->er['TermTaxonomy'];
    	}
    	$this->er['TermTaxonomy'] = $this->getEntityManager()->getRepository('Neobazaar\Entity\TermTaxonomy');
    	
    	return $this->er['TermTaxonomy'];
    }
745829
private function getRoleRepository()
    {
        if (null === $this->roleRepo) {
            $this->roleRepo = $this->getRepository(RoleInterface::class);
        }

        return $this->roleRepo;
    }
863807
protected function getTransUnitRepository()
    {
        if (null === $this->transUnitRepository) {
            $this->transUnitRepository = new TransUnitRepository($this->getConnection());
        }

        return $this->transUnitRepository;
    }
437214
public function getParentRepository()
    {
        if (null == $this->parentRepository) {
            $this->setParentRepository(
                Orm::getRepository($this->getParentEntity())
            );
        }
        return $this->parentRepository;
    }
245801
public function getRepository($entityName)
    {
        return new ListRepository($this->em, $this->em->getClassMetadata($entityName), $this);
    }
475728
private static function _getRepositoryManager()
	{
		self::_init();
		if (!self::$repositoryManager)
		{
			self::$repositoryManager = self::$composer->getRepositoryManager();
		}
		return self::$repositoryManager;
	}
646251
protected function getRepository ($persistentObject = null) : EntityRepository
    {
        if (null === $persistentObject)
        {
            $persistentObject = $this->getFullEntityName();
        }

        return $this->doctrine->getRepository($persistentObject);
    }
398504
public function getRepository($entityClass)
    {
        if (is_object($entityClass)) {
            $entityClass = get_class($entityClass);
        }

        if (!isset($this->repositories[$entityClass])) {
            throw new \Exception("no repository defined for: $entityClass");
        }

        if (!is_object($this->repositories[$entityClass])) {
            $this->repositories[$entityClass] = $this->di->get($this->repositories[$entityClass]);
        }

        return $this->repositories[$entityClass];
    }
453317
protected function getRepositoryUrlCache()
    {
        $repositoryUrlCache = $this->getSession()->get(SessionParameter::REPOSITORY_URL_CACHE);
        if ($repositoryUrlCache === null) {
            $repositoryUrlCache = new RepositoryUrlCache();
            $this->getSession()->put(SessionParameter::REPOSITORY_URL_CACHE, $repositoryUrlCache);
        }

        return $repositoryUrlCache;
    }
1189536
public function getCurrentRepository()
    {
        $credentials = $this->getRepositoryCredentials();
        $credentials['repository'] = $this->getRepositoryEndpoint();
        $credentials['branch'] = $this->getRepositoryBranch();

        return new RepositoryKey($credentials);
    }
924539
public function getRepository($entity)
    {
        $annotation = $this->getClassAnnotation($entity, self::DOCUMENT_CLASS);

        if ($annotation instanceof Document) {
            return $annotation->repository;
        }

        return '';
    }
949310
public function getRepository($name = null)
    {
        $name = strtolower($name);

        if ($name) {
            if (isset($this->repositories[$name])) {
                return $this->repositories[$name];
            }

            return $this->getNullRepository();
        }

        return $this->repository ?: $this->getNullRepository();
    }
1129907
public function getRepository(string $className): AbstractObjectRepository
    {
        $className = 'Infakt\\Repository\\'.substr($className, strrpos($className, '\\') + 1).'Repository';

        if (!class_exists($className)) {
            throw new LogicException("There is no repository to work with class $className.");
        }

        return new $className($this);
    }