Remove a builder for an action on a VM.

@param b the builder to remove
@return {@code true} if it has been removed
186013
public boolean remove(VMTransitionBuilder b) {
        Map<VMState, VMTransitionBuilder> m = vmAMB2.get(b.getDestinationState());
        for (VMState src : b.getSourceStates()) {
            m.remove(src);
        }
        return true;
    }
666566
public boolean remove()
    {
        if (_last1.key() == null)
            throw new java.util.NoSuchElementException(
                                                      "remove() without calling next()");

        boolean result = internalRemove();

        return result;
    }
540331
def remove(self, builder, model):
        
        column = model.get_qualified_deleted_at_column()

        query = builder.get_query()

        wheres = []
        for where in query.wheres:
            # If the where clause is a soft delete date constraint,
            # we will remove it from the query and reset the keys
            # on the wheres. This allows the developer to include
            # deleted model in a relationship result set that is lazy loaded.
            if not self._is_soft_delete_constraint(where, column):
                wheres.append(where)

        query.wheres = wheres
1047481
public Datatype.Builder setBuilderSerializable(boolean builderSerializable) {
    this.builderSerializable = builderSerializable;
    _unsetProperties.remove(Property.BUILDER_SERIALIZABLE);
    return (Datatype.Builder) this;
  }
639811
public static ServerBootstrap removeConfiguration(ServerBootstrap b, String name) {
		Objects.requireNonNull(b, "bootstrap");
		Objects.requireNonNull(name, "name");
		if (b.config().childHandler() != null) {
			b.childHandler(removeConfiguration(b.config().childHandler(), name));
		}
		return b;
	}
39620
public boolean remove(final ServerPresentationModel pm) {
        boolean deleted = super.remove(pm);
        if (!deleted) {
            throw new IllegalStateException("Model " + pm + " not found on the server!");
        }
        deleteCommand(getCurrentResponse(), pm.getId());
        return deleted;
    }
451612
public function remove(Builder $builder, Model $model)
    {
        $query = $builder->getQuery();

        foreach ((array)$query->wheres as $key => $where)
        {
            if ($where['column'] === $model->getTypeKeyName())
            {
                unset($query->wheres[$key]);

                $query->wheres = array_values($query->wheres);
            }
        }
    }
547522
public boolean removeOnTransactionBroadcastListener(OnTransactionBroadcastListener listener) {
        boolean result = ListenerRegistration.removeFromList(listener, peersTransactionBroadastEventListeners);
        for (Peer peer : getConnectedPeers())
            peer.removeOnTransactionBroadcastListener(listener);
        for (Peer peer : getPendingPeers())
            peer.removeOnTransactionBroadcastListener(listener);
        return result;
    }
215244
public boolean deleteBlob(String bucketName, String blobName) {
    // [START deleteBlob]
    BlobId blobId = BlobId.of(bucketName, blobName);
    boolean deleted = storage.delete(blobId);
    if (deleted) {
      // the blob was deleted
    } else {
      // the blob was not found
    }
    // [END deleteBlob]
    return deleted;
  }
34059
public ComponentBuilder moveComponent(final ComponentBuilder builder) {
        if (builder.getAnalysisJobBuilder() != this) {
            builder.getAnalysisJobBuilder().removeComponent(builder);

            // when moving the component to a different scope we need to first
            // reset
            // the prior input
            builder.clearInputColumns();

            addComponent(builder);
            builder.setAnalysisJobBuilder(this);
        }

        return builder;
    }
879296
boolean removeBlock(BlockInfo b) {
    blockList = b.listRemove(blockList, this);
    if ( b.removeNode(this) ) {
      numOfBlocks--;
      return true;
    } else {
      return false;
    }
  }
20506
public boolean remove(V value) {
        // peek at what is in the map
        K key = value.getKey();
        Ref<V> ref = map.get(key);
        // only try to remove the mapping if it matches the provided class loader
        return (ref != null && ref.get() == value) ? map.remove(key, ref) : false;
    }
611450
private void flagSFSBRemoveMethods(BeanMetaData bmd, final Method[] allMethodsOfEJB, Map<Method, ArrayList<EJBMethodInfoImpl>> methodInfoMap) throws EJBConfigurationException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        String ejbName = bmd.enterpriseBeanName;

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "flagSFSBRemoveMethods: " + ejbName);
        }

        // First process any method that is annotated as a remove method
        // if metadata complete is false. This is done first since the xml
        // can be used to override the retain if exception setting.
        if (!bmd.metadataComplete) {
            for (Method m : allMethodsOfEJB) {
                // Does this method have the Remove annotation?
                Remove ra = m.getAnnotation(Remove.class);
                if (ra != null) {
                    // find the list of EJBMEthodInfoImpl objects that need to be
                    // flagged as remove methods.
                    ArrayList<EJBMethodInfoImpl> infoList = methodInfoMap.get(m);
                    if (infoList == null) {
                        // CNTR0233E: The {1} enterprise bean specifies an @Remove annotation on the {0} method.
                        // This annotation is not valid because this method is not a business method of this bean.
                        String method = m.toGenericString();
                        Object[] data = new Object[] { method, ejbName };
                        Tr.error(tc, "INVALID_REMOVE_ANNOTATION_CNTR0233E", data);
                        throw new EJBConfigurationException("CNTR0233E:  The " + ejbName + " enterprise bean specifies an @Remove annotation on the " +
                                                            m.toGenericString()
                                                            + " method.  This annotation is not valid because this method is not a business method of this bean.");
                    } else {
                        // Get retainIfException from remove annotation
                        boolean retainIfException = ra.retainIfException();

                        // Flag each of the EJBMethodInfoImpl objects for this business method that
                        // it is a SFSB remove method.
                        for (EJBMethodInfoImpl methodInfo : infoList) {
                            methodInfo.setSFSBRemove(retainIfException);
                            if (isTraceOn && tc.isDebugEnabled()) {
                                Tr.debug(tc, "SFSB @Remove method: " + methodInfo.getInterfaceType()
                                             + " - " + methodInfo.getJDIMethodSignature()
                                             + ", retain-if-exception = " + retainIfException);
                            }
                        }
                    }
                }
            }
        }

        // Now augment or override the results of above processing with remove-method
        // defined in the ejb-jar.xml file (note, eb is set to null if there is no
        // ejb-jar.xml file).
        EnterpriseBean eb = bmd.wccm.enterpriseBean;
        if (eb != null) {
            // Get remove-method list for this Session bean from WCCM and process.
            Session sb = (Session) eb;
            List<RemoveMethod> rmList = sb.getRemoveMethod();
            for (RemoveMethod rm : rmList) {
                NamedMethod namedMethod = rm.getBeanMethod();
                String namedMethodName = namedMethod.getMethodName();
                ArrayList<EJBMethodInfoImpl> infoList = null;

                // Determine if the remove method was specified using style
                // 1, 2, or 3 and build the list of EJBMethodInfos that need
                // to be flagged as remove methods.                          d615325
                if ("*".equals(namedMethodName)) {
                    // style 1 - all methods are considered remove methods
                    infoList = new ArrayList<EJBMethodInfoImpl>(methodInfoMap.size());
                    for (ArrayList<EJBMethodInfoImpl> methodInfoList : methodInfoMap.values()) {
                        infoList.addAll(methodInfoList);
                    }
                } else if (namedMethod.getMethodParamList() == null) {
                    // style 2 - all methods with the same name are remove methods
                    infoList = new ArrayList<EJBMethodInfoImpl>();
                    for (Method method : methodInfoMap.keySet()) {
                        if (method.getName().equals(namedMethodName)) {
                            infoList.addAll(methodInfoMap.get(method));
                        }
                    }
                } else {
                    // style 3 - remove method must match both name and parameters
                    Method m = DDUtil.findMethod(namedMethod, allMethodsOfEJB);
                    if (m != null) {
                        infoList = methodInfoMap.get(m);
                    }
                }

                if (infoList == null || infoList.size() == 0) {
                    // CNTR0233E: Remove annotation can not be applied to method "{0}"
                    // since the method is not a business method of EJB name "{1}".
                    String method = namedMethod.getMethodName();
                    List<String> parms = namedMethod.getMethodParamList();
                    List<String> parmList = parms == null ? Collections.<String> emptyList() : parms;
                    method = method + parmList;
                    Object[] data = new Object[] { method, ejbName };
                    Tr.error(tc, "INVALID_REMOVE_ANNOTATION_CNTR0233E", data);
                    throw new EJBConfigurationException("remove-method annotation can not be applied to method \""
                                                        + method + "\" since the method is not a business method of EJB name \""
                                                        + ejbName + "\"");
                } else {
                    // Determine if retain-if-exception is set in ejb-jar.xml for this EJB.
                    boolean retainIfExceptionIsSet = rm.isSetRetainIfException(); //d454711

                    // Flag each of the EJBMethodInfoImpl objects for this business method that
                    // it is a SFSB remove method.
                    for (EJBMethodInfoImpl methodInfo : infoList) {
                        // Was method annotated as a remove method?
                        if (methodInfo.isSFSBRemoveMethod()) {
                            // Yep, it was annoted with Remove method. Is the ejb-jar.xml
                            // overriding the retain if exception setting?
                            if (retainIfExceptionIsSet) {
                                // Yep, ejb-jar.xml is overriding the retain if exception,
                                // so get setting from xml and set it in EJBMethodInfo object.
                                boolean retainIfException = rm.isRetainIfException();
                                methodInfo.setSFSBRemove(retainIfException);
                                if (isTraceOn && tc.isDebugEnabled()) {
                                    Tr.debug(tc, "SFSB remove-method: " + methodInfo.getInterfaceType()
                                                 + " - " + methodInfo.getJDIMethodSignature()
                                                 + ", ejb-jar.xml overriding retain-if-exception to be " + retainIfException);
                                }
                            }
                        } else {
                            // d454711
                            // Method was not annotated as a remove method, but it is a remove
                            // method in the xml file.  So flag method using information from xml file.
                            // Need to default retain if exception if not specified in xml file.
                            boolean retainIfException = (retainIfExceptionIsSet) ? rm.isRetainIfException() : false; //d454711
                            methodInfo.setSFSBRemove(retainIfException);
                            if (isTraceOn && tc.isDebugEnabled()) {
                                Tr.debug(tc, "SFSB remove-method: " + methodInfo.getInterfaceType()
                                             + " - " + methodInfo.getJDIMethodSignature()
                                             + ", retain-if-exception = " + retainIfException);
                            }
                        }
                    }
                }
            }
        }

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "flagSFSBRemoveMethods: " + ejbName);
        }
    }
339036
public void removeAttributeBuilder(AttributeWidgetBuilder<?> builder) {
		Iterator<AttributeWidgetBuilder<?>> iterator = builders.values().iterator();
		while (iterator.hasNext()) {
			AttributeWidgetBuilder<?> widgetBuilder = iterator.next();
			if (widgetBuilder.equals(builder)) {
				iterator.remove();
			}
		}
	}
1354763
public boolean actionRemoveAce() {

        String file = getParamResource();
        String name = getParamName();
        String type = getParamType();
        String uuid = getParamUuid();
        try {
            // lock resource if autolock is enabled
            checkLock(getParamResource());
            // check if it is the case of a role
            CmsRole role = CmsRole.valueOfGroupName(name);
            if (role != null) {
                // translate the internal group name to a role name
                name = role.getFqn();
            }
            try {
                getCms().rmacc(file, type, uuid);
            } catch (CmsException e) {
                LOG.warn(e.getLocalizedMessage(), e);
                getCms().rmacc(file, type, name);
            }
            return true;
        } catch (CmsException e) {
            m_errorMessages.add(key(Messages.ERR_CHACC_DELETE_ENTRY_0));
            if (LOG.isErrorEnabled()) {
                LOG.error(e.getLocalizedMessage(), e);
            }
            return false;
        }
    }
297223
public boolean removeStream(Stream stream) {
        final boolean removed = streams.remove(stream);

        if (removed) {
            indexSets.clear();
            for (Stream s : streams) {
                indexSets.add(s.getIndexSet());
            }
            sizeCounter.dec(8);
            if (LOG.isTraceEnabled()) {
                LOG.trace("[Message size update][{}] stream removed: {}", getId(), sizeCounter.getCount());
            }
        }

        return removed;
    }
752647
public function remove(Builder $builder, Model $model)
    {
        $table = $model->getVersionTable();

        $query = $builder->getQuery();

        $query->joins = collect($query->joins)->reject(function($join) use ($table)
        {
            return $this->isVersionJoinConstraint($join, $table);
        })->values()->all();
    }