Returns a repository specific version of this column if one is available.

If no repository specific version is available $this is passed back.

@param  string $repositoryClassName
@return Column
487443
final public function getRepositorySpecificColumn($repositoryClassName)
    {
        $reposName = basename(str_replace("\\", "/", $repositoryClassName));

        // Get the provider specific implementation of the column.
        $className = '\Rhubarb\Stem\Repositories\\' . $reposName . '\Schema\Columns\\' . $reposName . basename(str_replace("\\", "/", get_class($this)));

        if (class_exists($className)) {
            $superType = call_user_func_array($className . "::fromGenericColumnType", [$this]);

            // fromGenericColumnType could return false if it doesn't supply any schema details.
            if ($superType !== false) {
                return $superType;
            }
        }
        return $this;
    }
331363
public function getRepository(string $documentClass): Repository
    {
        $metadata = $this->getMetadata($documentClass);
        if ($metadata->isNested()) {
            throw new InvalidArgumentException(
                sprintf('Cannot get repository for nested document class "%s".', $documentClass)
            );
        }

        return $this->repositoryFactory->getRepository($this, $documentClass);
    }
475728
private static function _getRepositoryManager()
	{
		self::_init();
		if (!self::$repositoryManager)
		{
			self::$repositoryManager = self::$composer->getRepositoryManager();
		}
		return self::$repositoryManager;
	}
1257275
protected function getRepository($key)
    {
        $rep = $this->entityRepositories[$key];
        if ($rep) {
            return $this->getEntityManager()->getRepository($rep);
        }
    }
804425
public function getRepository()
    {
        if (!$this->_repository instanceof AnDomainRepositoryAbstract) {
            if (!$this->_repository instanceof AnServiceIdentifier) {
                $this->setRepository($this->_repository);
            }

            $this->_repository = $this->getService($this->_repository);
        }

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

        return $this->repository;
    }
162042
public function getRepositoryVersion()
    {
        $version = $this->complement['version'];

        if (! isset($this->complement['config-url'])) {
            return $version;
        }

        if (! File::exists($this->complement['config-url'])) {
            return $version;
        }

        $config = Json::fileToArray($this->complement['config-url']);
        $version = isset($config['version']) ? $config['version'] : $version;

        return $version;
    }
1224572
public function getRepository($entityName)
    {
        $resolvedEntityName = $this->getEntityManager()->getEntityClassByInterface($entityName);
        $objectManager = $this->getObjectManagerAutoDetector()->getObjectManagerByClassName($resolvedEntityName);
        return $objectManager->getRepository($resolvedEntityName);
    }
1171255
public function getRepository(EntityManagerInterface $entityManager, $entityName)
    {
        return $this->repositorySubManager->get($this->entityRepositoryMapping->getRepositoryByEntity($entityName));
    }
1190067
public function setRepository(Repository $repository, $default = null, $customName = null)
    {
        if ($default === true) {
            $this->repository = $repository;
        }

        $name = $customName ?: $repository->getName();
        $name = $name ?: uniqid();

        $this->repositories[strtolower($name)] = $repository;

        return $this;
    }
778780
public function getOne($repository, $id)
    {
        $repoConfig = $this->repos[$repository];
        /** @var $q \Doctrine\ORM\QueryBuilder */
        return $this->doctrine
            ->getRepository($repoConfig['repository'])
            ->find($id);
    }
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];
    }
789817
protected function getRepositoryUrl($repositoryId, $selector = null)
    {
        $result = $this->getRepositoryUrlCache()->getRepositoryUrl($repositoryId, $selector);

        if ($result === null) {
            $this->getRepositoriesInternal($repositoryId);
            $result = $this->getRepositoryUrlCache()->getRepositoryUrl($repositoryId, $selector);
        }

        if ($result === null) {
            throw new CmisObjectNotFoundException(
                sprintf(
                    'Unknown repository! Repository: "%s" | Selector: "%s"',
                    $repositoryId,
                    $selector
                )
            );
        }

        return $result;
    }
816229
protected function getRepository($repoId = null){
        if($repoId === null){
          $repo = $this->getRepository(static::REPOSITORY_NAMESPACE);
        }else{
          $repo = $this->getEntityManager()->getRepository($repoId);
        }
        return $repo;
    }
48016
public function getRepository()
    {
        if (!$this->_repository instanceof AnDomainRepositoryAbstract) {
            $this->_repository = $this->getService($this->_repository);
        }

        return $this->_repository;
    }
1239438
public VersionResource getVersion(String name) throws RepositoryException, IllegalResourceTypeException
   {
      return new VersionResource(versionURI(name), versionedResource, versionHistory.getVersion(name), namespaceContext);
   }
679522
public function getRepository($className = null){
      if($className === null){
        $repo = $this->getRepository(static::REPOSITORY_NAMESPACE);
      }else{
        $repo = $this->getEntityManager()->getRepository($className);
      }
      return $repo;
    }