remove a type from the array.  One use here would be if/when textLog is disabled
or when repository location is changed
@param repositoryType type of repository
776798
public synchronized void removeRepositoryInfo(LogRepositoryManager manager) {
		RepositoryInfo curRI = repositoryInfo.remove(manager);
		if (curRI != null) {
			curRI.setRespositorySpaceNeeded(0);
		}
	}
1713
public void removeTaskFromQueue(String taskType, String taskId) {
        Preconditions.checkArgument(StringUtils.isNotBlank(taskType), "Task type cannot be blank");
        Preconditions.checkArgument(StringUtils.isNotBlank(taskId), "Task id cannot be blank");

        delete("tasks/queue/{taskType}/{taskId}", taskType, taskId);
    }
871736
public void removeVar(String entityType, String attributeVar) {
        fullVars.remove(clashKey(entityType, attributeVar));
    }
581091
@Indexable(type = IndexableType.DELETE)
	@Override
	public CPSpecificationOption deleteCPSpecificationOption(
		CPSpecificationOption cpSpecificationOption) throws PortalException {
		return cpSpecificationOptionPersistence.remove(cpSpecificationOption);
	}
641452
public final void clearCache(final int viewType) {
        if (unusedViews != null) {
            unusedViews.remove(viewType);
        }

        logger.logDebug(getClass(),
                "Removed all unused views of view type " + viewType + " from cache");
    }
564754
private void removeVersionHistory(NodeData mixVersionableNode) throws RepositoryException,
      ConstraintViolationException, VersionException
   {
      try
      {
         PropertyData vhpd =
            (PropertyData)dataConsumer.getItemData(mixVersionableNode, new QPathEntry(Constants.JCR_VERSIONHISTORY, 1),
               ItemType.PROPERTY);

         String vhID = ValueDataUtil.getString(vhpd.getValues().get(0));
         VersionHistoryRemover historyRemover =
            new VersionHistoryRemover(vhID, dataConsumer, nodeTypeDataManager, repository, currentWorkspaceName, null,
               ancestorToSave, changesLog, accessManager, userState);
         historyRemover.remove();
      }
      catch (IllegalStateException e)
      {
         throw new RepositoryException(e);
      }
   }
612425
public void deleteAtlasTypeDefs(final AtlasTypesDef typesDef) throws AtlasServiceException {
        callAPI(DELETE_ALL_TYPE_DEFS, AtlasTypesDef.class, AtlasType.toJson(typesDef));
    }
538092
public void uncheckTypes(Collection<String> types) {

        for (String type : types) {
            CmsListItem item = (CmsListItem)m_scrollList.getItem(type);
            if (item != null) {
                item.getCheckBox().setChecked(false);
            }
        }
    }
1362403
public void unregisterTaskDef(String taskType) {
        Preconditions.checkArgument(StringUtils.isNotBlank(taskType), "Task type cannot be blank");
        stub.deleteTask(MetadataServicePb.DeleteTaskRequest.newBuilder()
                .setTaskType(taskType)
                .build()
        );
    }
589706
public static boolean removeFiles(String destinationType) {
		LogRepositoryManager destManager = getManager(destinationType) ;
		if (destManager instanceof LogRepositoryManagerImpl)
			return destManager.purgeOldFiles() ;
		else
			return false ;
	}
415505
@Override
    public void remove(Resource subject, URI predicate, Value object, Resource... contexts) throws RepositoryException {
        getClient().sendRemove(null, subject, predicate, object, contexts);
    }
915233
public function removeType(string $type)
    {
        if (!$this->removing && Type::hasType($type)) {
            $this->removing = true;
            Type::overrideType($type, null);
        }

        $this->removing = false;
        unset($this->types[$type]);
    }
474513
protected void removeRepositoryLocally(String repositoryName, boolean forceRemove) throws RepositoryCreationException
   {
      try
      {
         // extract list of all datasources
         ManageableRepository repositorty = repositoryService.getRepository(repositoryName);
         Set<String> datasources = extractDataSourceNames(repositorty.getConfiguration(), false);

         // close all opened sessions
         for (String workspaceName : repositorty.getWorkspaceNames())
         {
            WorkspaceContainerFacade wc = repositorty.getWorkspaceContainer(workspaceName);
            SessionRegistry sessionRegistry = (SessionRegistry)wc.getComponent(SessionRegistry.class);

            sessionRegistry.closeSessions(workspaceName);
         }

         // remove repository from configuration
         repositoryService.removeRepository(repositoryName, forceRemove);
         repositoryService.getConfig().retain();
         
         // unbind datasource and close connections
         for (String dsName : datasources)
         {
            try
            {
               // we suppose that lookup() method returns the same instance of datasource by the same name
               DataSource ds = (DataSource)initialContextInitializer.getInitialContext().lookup(dsName);
               initialContextInitializer.getInitialContextBinder().unbind(dsName);

               // close datasource
               if (ds instanceof CloseableDataSource)
               {
                  ((CloseableDataSource)ds).close();
               }
            }
            catch (NamingException e)
            {
               LOG.error("Can't unbind datasource " + dsName, e);
            }
            catch (FileNotFoundException e)
            {
               LOG.error("Can't unbind datasource " + dsName, e);
            }
            catch (XMLStreamException e)
            {
               LOG.error("Can't unbind datasource " + dsName, e);
            }
         }
      }
      catch (RepositoryException e)
      {
         throw new RepositoryCreationException("Can't remove repository", e);
      }
      catch (RepositoryConfigurationException e)
      {
         throw new RepositoryCreationException("Can't remove repository", e);
      }
   }
223060
private function checkQueryRepositoryCompatibility(string $type): void
    {
        if (self::ENDPOINT_SINGLE === $type && !$this->urlSingle) {
            throw new \InvalidArgumentException(\sprintf(
                'Trying to perform a single-type query on repository %s, which supports only collection type',
                $this->name
            ));
        }
        if (self::ENPOINT_COLLECTION === $type && !$this->urlCollection) {
            throw new \InvalidArgumentException(\sprintf(
                'Trying to perform a collection-type query on repository %s, which supports only single type',
                $this->name
            ));
        }
    }
17721
public void unsubscribe(Class<? extends Subscriber> subscriberType) {
        for (ArrayList<Class<? extends Subscriber>> list : subscriptionMap.values()) {
            list.remove(subscriberType);
        }
    }
1265263
public void removeRepository(String id) {
      for (UpdateRepository repo : getRepositories()) {
        if (id.equals(repo.getId())) {
          repositories.remove(repo);
          break;
        }
      }
      log.warn("Repository with id " + id + " not found, doing nothing");
    }
410438
@Override
    public void remove(Class<? extends IBasicEntity> type, String key) throws CachingException {
        EntityCachingServiceLocator.getEntityCachingService().remove(type, key);
    }