Need to remove this for Liberty Messaging (Holding it till review happens)
344118
@Deprecated
    private void checkProducerAuthority(SIDestinationAddress destAddr,
                                        DestinationHandler destination,
                                        String destinationName,
                                        String busName,
                                        SecurityContext secContext,
                                        boolean system)
                    throws SIDiscriminatorSyntaxException, SINotAuthorizedException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "checkProducerAuthority",
                        new Object[] { destAddr,
                                      destination,
                                      destinationName,
                                      busName,
                                      secContext,
                                      Boolean.valueOf(system) });

        // Check authority to produce to destination unless we're sending to a system
        // queue in the local bus.
        if (!system || (destAddr.getBusName() == null) || destAddr.getBusName().equals(_messageProcessor.getMessagingEngineBus()))
        {
            // Perform the alternate user check first. If an alternateUser was set then we 
            // need to determine whether the connected subject has the authority to perform
            // alternate user checks.

            if (secContext.isAlternateUserBased())
            {
                if (!destination.checkDestinationAccess(secContext,
                                                        OperationType.IDENTITY_ADOPTER))
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "checkProducerAuthority", "not authorized to perform alternate user checks on this destination");

                    // Get the username
                    String userName = secContext.getUserName(true);
                    // Build the message for the Exception and the Notification
                    String nlsMessage =
                                    nls_cwsik.getFormattedMessage("DELIVERY_ERROR_SIRC_18", // USER_NOT_AUTH_SEND_ERROR_CWSIP0306
                                                                  new Object[] { destinationName,
                                                                                userName },
                                                                  null);

                    // Fire a Notification if Eventing is enabled
                    _accessChecker.
                                    fireDestinationAccessNotAuthorizedEvent(destinationName,
                                                                            userName,
                                                                            OperationType.IDENTITY_ADOPTER,
                                                                            nlsMessage);

                    // Thrown if user denied access to destination
                    SIMPNotAuthorizedException e = new SIMPNotAuthorizedException(nlsMessage);

                    e.setExceptionReason(SIRCConstants.SIRC0018_USER_NOT_AUTH_SEND_ERROR);
                    e.setExceptionInserts(new String[] { destinationName, secContext.getUserName(true) });

                    throw e;
                }
            }

            if (!destAddr.isTemporary()) // Non-temorary destination access check
            {
                if (!destination.checkDestinationAccess(secContext,
                                                        OperationType.SEND))
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "checkProducerAuthority", "not authorized to produce to this destination");

                    // Get the username
                    String userName = secContext.getUserName(false);
                    // Build the message for the Exception and the Notification
                    String nlsMessage =
                                    nls_cwsik.getFormattedMessage("DELIVERY_ERROR_SIRC_18", // USER_NOT_AUTH_SEND_ERROR_CWSIP0306
                                                                  new Object[] { destinationName,
                                                                                userName },
                                                                  null);

                    // Fire a Notification if Eventing is enabled
                    _accessChecker.
                                    fireDestinationAccessNotAuthorizedEvent(destinationName,
                                                                            userName,
                                                                            OperationType.SEND,
                                                                            nlsMessage);

                    // Thrown if user denied access to destination
                    SIMPNotAuthorizedException e = new SIMPNotAuthorizedException(nlsMessage);

                    e.setExceptionReason(SIRCConstants.SIRC0018_USER_NOT_AUTH_SEND_ERROR);
                    e.setExceptionInserts(new String[] { destinationName, secContext.getUserName(false) });

                    throw e;
                }
            }
            else // Check authority to produce to temp topic
            {
                // get the temp prefix from the destination name
                String destinationPrefix = SIMPUtils.parseTempPrefix(destinationName);
                if (!_accessChecker.checkTemporaryDestinationAccess(secContext,
                                                                    destinationName, // name of destination  
                                                                    (destinationPrefix == null) ? "" : destinationPrefix, // sib.security wants empty string if prefix is null
                                                                    OperationType.SEND))
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "checkProducerAuthority", "not authorized to produce to temporary destination");

                    // Get the username
                    String userName = secContext.getUserName(false);
                    // Build the message for the Exception and the Notification
                    String nlsMessage =
                                    nls_cwsik.getFormattedMessage("DELIVERY_ERROR_SIRC_19", // USER_NOT_AUTH_SEND_ERROR_CWSIP0306
                                                                  new Object[] { destinationPrefix,
                                                                                userName },
                                                                  null);

                    // Fire a Notification if Eventing is enabled
                    _accessChecker.
                                    fireDestinationAccessNotAuthorizedEvent(destinationPrefix,
                                                                            userName,
                                                                            OperationType.SEND,
                                                                            nlsMessage);

                    // Thrown if user denied access to destination
                    SIMPNotAuthorizedException e = new SIMPNotAuthorizedException(nlsMessage);

                    e.setExceptionReason(SIRCConstants.SIRC0019_USER_NOT_AUTH_SEND_ERROR);
                    e.setExceptionInserts(new String[] { destinationPrefix, secContext.getUserName(false) });

                    throw e;
                }
            }

            // Check authority to produce to discriminator
            if (secContext.testDiscriminatorAtCreate())
            {
                if (!destination.checkDiscriminatorAccess(secContext,
                                                          OperationType.SEND))
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "checkProducerAuthority", "not authorized to produce to this destination's discriminator");
                    // Write an audit record if access is denied
                    SibTr.audit(tc, nls_cwsik.getFormattedMessage(
                                                                  "DELIVERY_ERROR_SIRC_20", // USER_NOT_AUTH_SEND_ERROR_CWSIP0308
                                                                  new Object[] { destination.getName(),
                                                                                secContext.getDiscriminator(),
                                                                                secContext.getUserName(false) },
                                                                  null));

                    // Thrown if user denied access to destination
                    SIMPNotAuthorizedException e = new SIMPNotAuthorizedException(
                                    nls_cwsik.getFormattedMessage(
                                                                  "DELIVERY_ERROR_SIRC_20", // USER_NOT_AUTH_SEND_ERROR_CWSIP0308
                                                                  new Object[] { destination.getName(),
                                                                                secContext.getDiscriminator(),
                                                                                secContext.getUserName(false) },
                                                                  null));

                    e.setExceptionReason(SIRCConstants.SIRC0020_USER_NOT_AUTH_SEND_ERROR);
                    e.setExceptionInserts(new String[] { destination.getName(),
                                                        secContext.getDiscriminator(),
                                                        secContext.getUserName(false) });
                    throw e;
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "checkProducerAuthority");
    }
1051679
def _remove_ordered_from_queue(self, last_caught_up_3PC=None):
        
        to_remove = []
        for i, msg in enumerate(self.outBox):
            if isinstance(msg, Ordered) and \
                    (not last_caught_up_3PC or
                     compare_3PC_keys((msg.viewNo, msg.ppSeqNo), last_caught_up_3PC) >= 0):
                to_remove.append(i)

        self.logger.trace('{} going to remove {} Ordered messages from outbox'.format(self, len(to_remove)))

        # Removing Ordered from queue but returning `Ordered` in order that
        # they should be processed.
        removed = []
        for i in reversed(to_remove):
            removed.insert(0, self.outBox[i])
            del self.outBox[i]
        return removed
588577
private void remove_poll_object(final DeviceProxy deviceProxy, final String objname,
            final String objtype) throws DevFailed {
        // Send command on administration device.
        if (deviceProxy.getAdm_dev() == null) {
            import_admin_device(deviceProxy, "remove_poll_object");
        }
        if (DeviceProxy.isCheck_idl() && deviceProxy.getAdm_dev().get_idl_version() < 2) {
            Except.throw_non_supported_exception("TangoApi_IDL_NOT_SUPPORTED",
                "Not supported by the IDL version used by device", deviceProxy
                    .getFull_class_name()
                    + ".remove_poll_object()");
        }

        final DeviceData argin = new DeviceData();
        final String[] params = new String[3];
        params[0] = deviceProxy.devname;
        params[1] = objtype;
        params[2] = objname.toLowerCase();
        argin.insert(params);
        deviceProxy.getAdm_dev().command_inout("RemObjPolling", argin);
    }
667146
def remove_app_when_mdm_profile_is_removed=(new_val)
      return nil if new_val == @remove_app_when_mdm_profile_is_removed
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @remove_app_when_mdm_profile_is_removed = new_val
      @need_to_update = true
    end
1340695
def delete(message)
      sqs.delete_message queue_url: url_for_queue(message.queue), receipt_handle: message.receipt_handle
    end
1349749
function _removeIdlePromise(idleQueue, promise) {
    if (!promise) return;

    // remove timeout if exists
    if (promise._timeoutObj)
        clearTimeout(promise._timeoutObj);

    // remove handle-nr if exists
    if (idleQueue._pHM.has(promise)) {
        const handle = idleQueue._pHM.get(promise);
        idleQueue._hPM.delete(handle);
        idleQueue._pHM.delete(promise);
    }

    // remove from queue
    idleQueue._iC.delete(promise);
}
980062
public boolean removeNamedGroupingPolicy(String ptype, List<String> params) {
        boolean ruleRemoved = removePolicy("g", ptype, params);

        if (autoBuildRoleLinks) {
            buildRoleLinks();
        }
        return ruleRemoved;
    }
870182
private void remove() {
        if (removing) {
            return;
        }
        if (deactiveNotifications.size() == 0) {
            return;
        }
        removing = true;
        final NotificationPopupView view = deactiveNotifications.get(0);
        final LinearFadeOutAnimation fadeOutAnimation = new LinearFadeOutAnimation(view) {

            @Override
            public void onUpdate(double progress) {
                super.onUpdate(progress);
                for (int i = 0; i < activeNotifications.size(); i++) {
                    NotificationPopupView v = activeNotifications.get(i);
                    final int left = v.getPopupLeft();
                    final int top = (int) (((i + 1) * SPACING) - (progress * SPACING));
                    v.setPopupPosition(left,
                                       top);
                }
            }

            @Override
            public void onComplete() {
                super.onComplete();
                view.hide();
                deactiveNotifications.remove(view);
                activeNotifications.remove(view);
                removing = false;
                remove();
            }
        };
        fadeOutAnimation.run(500);
    }
479399
def drop_message(self, message):
        """"""

        for type_ in 'errors', 'warnings', 'notices':
            list_ = getattr(self, type_)
            if message in list_:
                list_.remove(message)
                if 'signing_severity' in message:
                    self.signing_summary[message['signing_severity']] -= 1
                return True

        return False
813217
def clearAnnouncements(self):
        
        try:
            q = models.Announcement.delete().where(
                models.Announcement.id > 0)
            q.execute()
        except Exception as e:
            raise exceptions.RepoManagerException(e)
1174840
def remove_callback(self, handle):
        """"""
        if self._poll is None:
            raise RuntimeError('poll instance is closed')
        remove_callback(self, handle)
        if handle.extra & READABLE:
            self._readers -= 1
        if handle.extra & WRITABLE:
            self._writers -= 1
        self._sync()
876626
def remove_permission(self, label, callback=None):
        
        return self.connection.remove_permission(self, label, callback=callback)
476829
private void removePreferenceFragmentUnconditionally() {
        if (isPreferenceFragmentShown()) {
            resetTitle();
            hideToolbarNavigationIcon();
            adaptBreadCrumbVisibility();
            FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
            transaction.remove(preferenceFragment);

            if (!isSplitScreen()) {
                transaction.show(navigationFragment);
            }

            transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_CLOSE);
            transaction.commit();
            notifyOnPreferenceFragmentHidden(preferenceFragment);
            preferenceFragment = null;
        }
    }
333290
protected void removeMessage(LMEMessage message)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "removeMessage", new Object[] {new Integer(hashCode()), message, this });

    // If this was the message we entered the callback with we need
    // to move the start point back a bit
    if(message == callbackEntryMsg)
      callbackEntryMsg = message.previous;

    // If this is our current message we need to move the cursor
    // back a bit
    if(message == currentMsg)
      currentMsg = message.previous;

    // If this message was the next to expire we move the expiry cursor on to
    // the next eligible message. We leave any alarm registered so that it pops,
    // when this happens it realises the alarm is not valid for the next expiring
    // message and re-registers itself for the correct time. This gives us the
    // best performance when no locks are expiring as we're not continually
    // registering and de-registering alarms for every message
    if(message == nextMsgToExpire)
    {
      do
      {
        nextMsgToExpire = nextMsgToExpire.next;
      }
      while((nextMsgToExpire != null) && (nextMsgToExpire.expiryTime == 0));
    }

    if(message == nextMsgReferenceToExpire)
    {
      do
      {
        nextMsgReferenceToExpire = nextMsgReferenceToExpire.next;
      }
      while((nextMsgReferenceToExpire != null) && (nextMsgReferenceToExpire.expiryTime == 0));
    }

    // Unlink this message from the list
    if(message.previous != null)
      message.previous.next = message.next;
    else
      firstMsg = message.next;

    if(message.next != null)
      message.next.previous = message.previous;
    else
      lastMsg = message.previous;

    // Pool the element if there's space
    if(pooledCount < poolSize)
    {
      message.message = null;
      message.next = pooledMsg;
      message.previous = null;
      message.owner = null;
      message.jsMessage = null;
      message.expiryTime = 0;
      message.expiryMsgReferenceTime = 0;
      pooledMsg = message;
      pooledCount++;
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeMessage", this);
  }
518283
public void removeDuplicateFilters(JMessageListener listenerToCheck)
    {
        for (int iIndex = 0; ; iIndex++)
        {
            BaseMessageFilter filter = listenerToCheck.getListenerMessageFilter(iIndex);
            if (filter == null)
                break;
            if (this.isSameFilter(filter))
            {
                if (filter.getMessageListener(1) == null)
                {   // Only free if the message list is the same and only
                    filter.removeFilterMessageListener(listenerToCheck);
                // DO NOT free the listener.
                    filter.free();     // Cool, it was a dup... get rid of it.
                    iIndex--;
                }
            }
        }
    }
116874
def _remove(self, xer, primary):
        
        if xer in primary:
            notifier = primary.pop(xer)
            notifier.shutdown()
50542
function removePhaseListener(priv, listener) {
  check(listener, 'listener').is.aFunction.and.is.oneOf(priv.listeners, 'registered listeners')();
  priv.listeners.splice(priv.listeners.indexOf(listener), 1);
}