/* (non-Javadoc)
@see net.timewalker.ffmq4.common.connection.AbstractConnection#deleteTemporaryTopic(java.lang.String)
12401
@Override
	public final void deleteTemporaryTopic(String topicName) throws JMSException
    {
        engine.deleteTopic(topicName);
        unregisterTemporaryTopic(topicName);
    }
1339602
public synchronized void removeTimestamp(long ts) throws NoSuchElementException {
    Preconditions.checkState(!closed, "tracker closed ");
    Preconditions.checkState(allocationsInProgress > 0,
        "allocationsInProgress should be > 0 " + allocationsInProgress);
    Objects.requireNonNull(node);
    if (timestamps.remove(ts) == false) {
      throw new NoSuchElementException(
          "Timestamp " + ts + " was previously removed or does not exist");
    }

    allocationsInProgress--;
  }
1193237
public final void checkTemporaryDestinationScope( Destination destination ) throws JMSException
    {
    	if (destination instanceof LocalQueue)
    	{
    		LocalQueue localQueue = (LocalQueue)destination; 
	        if (localQueue.isTemporary() && !connection.isRegisteredTemporaryQueue(localQueue.getQueueName()))
	       		throw new IllegalStateException("Temporary queue does not belong to session's connection.");
    	}
    	else
    	if (destination instanceof LocalTopic)
    	{	
    		LocalTopic localTopic = (LocalTopic)destination; 
	        if (localTopic.isTemporary() && !connection.isRegisteredTemporaryTopic(localTopic.getTopicName()))
	       		throw new IllegalStateException("Temporary topic does not belong to session's connection.");
    	}
    	else
    		throw new FFMQException("Unexpected destination type : "+destination,"INTERNAL_ERROR");
    }
789678
static function removeTemporary()
    {
        $version = eZContentClass::VERSION_STATUS_TEMPORARY;
        $temporaryClasses = eZContentClass::fetchList( $version, true );
        $db = eZDB::instance();
        $db->begin();
        foreach ( $temporaryClasses as $class )
        {
            $class->remove( true, $version );
        }
        eZPersistentObject::removeObject( eZContentClassAttribute::definition(),
                                          array( 'version' => $version ) );

        $db->commit();
    }
728063
@Override
	public void delete() throws JMSException
    {
        if (connection == null)
            throw new FFMQException("Temporary queue already deleted","QUEUE_DOES_NOT_EXIST");
            
        connection.deleteTemporaryQueue(name);
        connection = null;
    }
1029736
public void setTimestamp(Timestamp timestamp) {
        if (timestamp == null) {
            _properties.remove(AMQP_PROP_TIMESTAMP);
            return;
        }
        
        _properties.put(AMQP_PROP_TIMESTAMP, timestamp);
    }
611691
@Override
	public Collection<String> removeSessionToTopics(Session session) {
		if (session != null) {
			return removeSessionsToTopic(Arrays.asList(session));
//			for (String topic : map.keySet()) {
//				sendSubscriptionEvent(Constants.Topic.SUBSCRIBERS + Constants.Topic.COLON + topic, unregisterTopicSession(topic, session));
//			}
		}
		return Collections.EMPTY_LIST;
	}
955934
public void deleteCurrent(SITransaction simpTran)
  throws SISessionUnavailableException, SISessionDroppedException,
         SIIncorrectCallException,
         SIErrorException
  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "deleteCurrent", this);
      
    checkValidState("deleteCurrent");
    
    _localConsumerPoint.checkNotClosed();
    
    if (!_messageAvailable)
    {
      if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
        SibTr.exit(CoreSPILockedMessageEnumeration.tc, "deleteCurrent", "Invalid current Message");
        
      throw new SIIncorrectCallException(
        nls.getFormattedMessage("INVALID_MESSAGE_ERROR_CWSIP0191", 
          new Object[] { _localConsumerPoint.getConsumerManager().getDestination().getName(),
            _localConsumerPoint.getConsumerManager().getMessageProcessor().getMessagingEngineName() }, 
          null));
    }
    
    _singleMessage = null;
    _messageAvailable = false;
    
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.exit(CoreSPILockedMessageEnumeration.tc, "deleteCurrent");
  }
860205
@Override
    public CompletableFuture<Void> removeSetItemAsync(String key, V value) {
        return (CompletableFuture) send("SREM", null, (Type) null, key, key.getBytes(UTF8), formatValue(CacheEntryType.OBJECT, (Type) null, value));
    }
802055
protected void addTemporaryDestination(JmsTemporaryDestinationInternal tempDest) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "addTemporaryDestination", System.identityHashCode(tempDest));

        synchronized (temporaryDestinations) { // synchronize against removeTemporaryDestination
            temporaryDestinations.add(tempDest);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "addTemporaryDestination");
    }
921945
private void deleteTimes() throws IfmapErrorResult, IfmapException {
		String filter = IfmapStrings.OP_METADATA_PREFIX + ":client-time[@" + IfmapStrings.PUBLISHER_ID_ATTR
			+ " = \"" + mSsrc.getPublisherId() + "\"]";
		PublishDelete pd = Requests.createPublishDelete(mDev, filter);
		pd.addNamespaceDeclaration(IfmapStrings.OP_METADATA_PREFIX,
				IfmapStrings.OP_METADATA_NS_URI);
		PublishRequest pr = Requests.createPublishReq(pd);

		mSsrc.publish(pr);
	}
1084389
@SuppressWarnings("unchecked")
    public boolean postValidateInfoTopic(final InfoTopic infoTopic, final ContentSpec contentSpec) {
        // Check if the app should be shutdown
        if (isShuttingDown.get()) {
            shutdown.set(true);
            return false;
        }

        boolean valid = true;

        // New Topics
        if (infoTopic.isTopicANewTopic()) {
            // Validate the tags
            if (!validateTopicTags(infoTopic, infoTopic.getTags(false))) {
                valid = false;
            }

            // Check Assigned Writer exists
            if (!postValidateAssignedWriter(infoTopic)) {
                valid = false;
            }
        }
        // Existing Topics
        else if (infoTopic.isTopicAnExistingTopic()) {
            // Calculate the revision for the topic
            final Integer revision;
            if (infoTopic.getRevision() == null && processingOptions.getMaxRevision() != null) {
                revision = processingOptions.getMaxRevision();
            } else {
                revision = infoTopic.getRevision();
            }

            // Check that the id actually exists
            BaseTopicWrapper<?> topic = null;
            try {
                if (processingOptions.isTranslation()) {
                    topic = EntityUtilities.getTranslatedTopicByTopicId(factory, Integer.parseInt(infoTopic.getId()), revision,
                            processingOptions.getTranslationLocale() == null ? defaultLocale : processingOptions.getTranslationLocale());
                } else {
                    topic = topicProvider.getTopic(Integer.parseInt(infoTopic.getId()), revision);
                }
            } catch (NotFoundException e) {
                log.debug("Could not find topic for id " + infoTopic.getDBId());
            }

            // Check that the topic actually exists
            if (topic == null) {
                log.error(String.format(ProcessorConstants.ERROR_TOPIC_NONEXIST_MSG, infoTopic.getLineNumber(), infoTopic.getText()));
                valid = false;
            } else {
                infoTopic.setTopic(topic);

                // Check to see if the topic contains the "Internal-Only" tag
                if (serverEntities.getInternalOnlyTagId() != null && topic.hasTag(serverEntities.getInternalOnlyTagId())) {
                    log.warn(String.format(ProcessorConstants.WARN_INTERNAL_TOPIC_MSG, infoTopic.getLineNumber(), infoTopic.getText()));
                }

                if (!postValidateExistingTopic(infoTopic, topic, contentSpec)) {
                    valid = false;
                }
            }
            // Cloned Topics
        } else if (infoTopic.isTopicAClonedTopic()) {
            // Get the original topic from the database
            int topicId = Integer.parseInt(infoTopic.getId().substring(1));
            TopicWrapper topic = null;
            try {
                topic = topicProvider.getTopic(topicId, infoTopic.getRevision());
            } catch (NotFoundException e) {
                log.debug("Could not find topic for id " + topicId);
            }

            // Check that the original topic was found
            if (topic == null) {
                log.error(String.format(ProcessorConstants.ERROR_TOPIC_NONEXIST_MSG, infoTopic.getLineNumber(), infoTopic.getText()));
                valid = false;
            } else {
                if (!postValidateExistingTopic(infoTopic, topic, contentSpec)) {
                    valid = false;
                }

                // Check Assigned Writer exists
                if (!postValidateAssignedWriter(infoTopic)) {
                    valid = false;
                }
            }
        }

        return valid;
    }
1093125
protected void removeLastInstanceActiveTime(String instanceId, T jedis){
        jedis.hdel(redisSchema.lastInstanceActiveTime(), instanceId);
    }
481181
private CompletableFuture<Revision> removePermissionAtPointer(Author author, String projectName,
                                                                  JsonPointer path, String commitSummary) {
        final Change<JsonNode> change = Change.ofJsonPatch(METADATA_JSON,
                                                           new RemoveOperation(path).toJsonNode());
        return metadataRepo.push(projectName, Project.REPO_DOGMA, author, commitSummary, change);
    }
627314
public ApiResponse<DeleteMetadataResponse> deleteMetadataWithHttpInfo(String location) throws ApiException {
        com.squareup.okhttp.Call call = deleteMetadataValidateBeforeCall(location, null, null);
        Type localVarReturnType = new TypeToken<DeleteMetadataResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
985005
@Override
	public synchronized void delete(long historyId, String tag) throws DatabaseException {
    	try {
			psDeleteTag.setLong(1, historyId);
			psDeleteTag.setString(2, tag);
			psDeleteTag.executeUpdate();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		}
    }
422587
public void setTimestampProperty(String pstrSection, String pstrProp, 
                    					Timestamp ptsVal, String pstrComments)
    {
        INISection objSec   = null;

        objSec = (INISection) this.mhmapSections.get(pstrSection);
        if (objSec == null)
        {
            objSec = new INISection(pstrSection);
            this.mhmapSections.put(pstrSection, objSec);
        }
        objSec.setProperty(pstrProp, timeToStr(ptsVal, this.mstrTimeStampFmt), 
                        	pstrComments);
    }