Get working repository name. Returns the repository name from configuration
if it previously configured and returns the name of current repository in other case.

@return String
repository name
@throws RepositoryException
770645
private String getWorkingRepositoryName() throws RepositoryException
   {
      if (observationListenerConfiguration.getRepository() == null)
      {
         return repositoryService.getCurrentRepository().getConfiguration().getName();
      }
      else
      {
         return observationListenerConfiguration.getRepository();
      }
   }
169845
public function getRepositoryConfig()
    {
        // Takes configured repository as the reference, if it exists.
        // If not, the first configured repository is considered instead.
        $repositoryAlias = $this->configResolver->getParameter('repository');
        if ($repositoryAlias === null) {
            $aliases = array_keys($this->repositories);
            $repositoryAlias = array_shift($aliases);
        }

        if (empty($repositoryAlias) || !isset($this->repositories[$repositoryAlias])) {
            throw new InvalidRepositoryException(
                "Undefined repository '$repositoryAlias'. Did you forget to configure it in ezpublish_*.yml?"
            );
        }

        return array('alias' => $repositoryAlias) + $this->repositories[$repositoryAlias];
    }
976345
@Override
    public String getFilename() {
        try {
            if (hasDescriptionProperty(FILENAME)) {
                return getDescriptionProperty(FILENAME).getString().replace(FIELD_DELIMITER + XSDstring.getURI(), "");
            }
            return node.getName();
        } catch (final RepositoryException e) {
            throw new RepositoryRuntimeException(e);
        }
    }
1208108
protected function getRepository(): AbstractRepository
    {
        return $this->getRepositoryFactory()->getRepositoryForEntity(
            AbstractRepository::getEntityNameFromClassName($this->getEntityClassName()),
            $this->connectionName
        );
    }
657735
final public function getName(): string
    {
        try {
            $reflexionConstant = new ReflectionClassConstant($this, 'NAME');
            $this->name        = $reflexionConstant->getValue();
        }
        catch (Exception $e) {
        }

        return $this->name;
    }
513921
protected function getTranslationRepository()
    {
        if (null === $this->translationRepository) {
            $this->translationRepository = new TranslationRepository($this->getConnection());
        }

        return $this->translationRepository;
    }
939928
public String getName() throws URIException {
        char[] basename = getRawName();
        return (basename == null) ? null : decode(getRawName(),
                getProtocolCharset());
    }
1108961
public function getRepository()
    {
        if (null === $this->repository) {
            $this->repository = $this->getBaseRepository();
            if ($this->hasContext()) {
                $this->repository .= DIRECTORY_SEPARATOR.$this->context;
            }
        }

        return $this->repository;
    }
934829
private function getRegistryRepository()
    {
        $repository = null;
        if (null !== $em = $this->_context->getApplication()->getEntityManager()) {
            $repository = $em->getRepository('BackBee\Bundle\Registry');
        }

        return $repository;
    }
371589
public function getRepositoryForClassName($className)
    {
        if (array_key_exists($className, $this->repositories)) {
            return $this->repositories[$className];
        }

        throw new RepositoryNotFoundException($className);
    }
296346
public function getRepositoryFactory(): RepositoryFactoryInterface
    {
        if (null !== $this->repositoryFactory) {
            return $this->repositoryFactory;
        }

        $factory = new DefaultRepositoryFactory();
        $factory->setDefaultRepositoryClassName($this->getDefaultRepositoryClassName());

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

        return new $repositoryName($this->getValidator(), $this->config);
    }
391276
public static Repository getRepository( String repositoryName ) throws NoSuchRepositoryException {
        Repository repository = null;
        try {
            repository = repositoriesContainer.getRepository(repositoryName, Collections.unmodifiableMap(factoryParams));
        } catch (RepositoryException e) {
            throw new NoSuchRepositoryException(WebJcrI18n.cannotInitializeRepository.text(repositoryName), e);
        }

        if (repository == null) {
            throw new NoSuchRepositoryException(WebJcrI18n.repositoryNotFound.text(repositoryName));
        }
        return repository;
    }
1299093
public function getRepository($entityName)
    {
        $entityName = ltrim($entityName, '\\');
        if (isset($this->repositories[$entityName])) {
            return $this->repositories[$entityName];
        }

        $metadata = $this->getClassMetadata($entityName);
        $customRepositoryClassName = $metadata->customRepositoryClassName;

        if ($customRepositoryClassName !== null) {
            $repository = new $customRepositoryClassName($this, $metadata);
        } else {
            $repository = new XmlEntityRepository($this, $metadata);
        }

        $this->repositories[$entityName] = $repository;

        return $repository;
    }
1115726
private function getRepositoryContent()
    {
        if ($this->contents === null) {
            $this->contents = $this->getRepositoryApi()->contents();
        }
        return $this->contents;
    }
572291
public String[] getMixinTypeNames() throws RepositoryException
   {
      NodeType[] mixinTypes = getMixinNodeTypes();
      String[] mtNames = new String[mixinTypes.length];
      for (int i = 0; i < mtNames.length; i++)
      {
         mtNames[i] = mixinTypes[i].getName();
      }

      return mtNames;
   }
1341988
public function getNullRepository()
    {
        if (!$this->nullRepository) {
            $this->nullRepository = new Repository();

            $this->nullRepository['is.null'] = true;
            $this->nullRepository['null']    = true;

            return $this->nullRepository;
        }

        return $this->nullRepository;
    }