<p>removeServlet.</p>

@param mountPoint a {@link java.lang.String} object.
168638
public final void removeServlet(String mountPoint) {
        mountPoint = GenericContext.normalizeMountPoint(mountPoint);
        synchronized (servlets) {
            ServletDescriptor remove = servlets.remove(mountPoint);
            if (remove != null) {
                unregisterServletDescriptor(remove);
            }
        }

    }
153144
def unmount(self, path):
        
        del self._mountpoints[self._join_chunks(self._normalize_path(path))]
1095464
@Override
    public void unregisterEndpoint(QName serviceName, String endpointURL)
            throws ServiceLocatorFault, InterruptedExceptionFault {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Unregistering endpoint " + endpointURL + " for service "
                    + serviceName + "...");
        }
        try {
            initLocator();
            locatorClient.unregister(serviceName, endpointURL);
        } catch (ServiceLocatorException e) {
            ServiceLocatorFaultDetail serviceFaultDetail = new ServiceLocatorFaultDetail();
            serviceFaultDetail.setLocatorFaultDetail(serviceName.toString()
                    + "throws ServiceLocatorFault");
            throw new ServiceLocatorFault(e.getMessage(), serviceFaultDetail);
        } catch (InterruptedException e) {
            InterruptionFaultDetail interruptionFaultDetail = new InterruptionFaultDetail();
            interruptionFaultDetail.setInterruptionDetail(serviceName
                    .toString() + "throws InterruptionFault");
            throw new InterruptedExceptionFault(e.getMessage(),
                    interruptionFaultDetail);
        }
    }
907652
synchronized boolean removeMapping(String virtualHost, HttpContext context)
    {
        boolean existing=false;
        if (_virtualHostMap!=null)
        {
            PathMap contextMap=(PathMap)_virtualHostMap.get(virtualHost);
            
            Iterator i2=contextMap.values().iterator();
            while(i2.hasNext())
            {
                List contextList = (List)i2.next();
                if (contextList.remove(context))
                    existing=true;                
                if (contextList.size()==0)
                    i2.remove();
            }
        }
        return existing;
    }
1133477
public void remove(String name) {
        EndpointService<L, S> service = endpointServices.remove(name);
        if (service != null) {
            service.stop();
            log.infoRemovedEndpointService(service.toString());
        }
    }
357422
public final void removeServer(String hostList) {
    List<InetSocketAddress> addresses = AddrUtil.getAddresses(hostList);
    if (addresses != null && addresses.size() > 0) {
      for (InetSocketAddress address : addresses) {
        removeAddr(address);
      }

    }

  }
165381
@PostMapping("/deletesingletag")
  public @ResponseBody void deleteSingleTag(@Valid @RequestBody RemoveTagRequest request) {
    ontologyTagService.removeAttributeTag(
        request.getEntityTypeId(),
        request.getAttributeName(),
        request.getRelationIRI(),
        request.getOntologyTermIRI());
  }
138237
public void removeService(ServiceReference reference, Object service) {
        if (serviceRegistration != null) {
            serviceRegistration.unregister();
            serviceRegistration = null;
        }

        String alias = this.getAlias();
        ((HttpService) service).unregister(alias);
        if (servlet instanceof WebappServlet)
            ((WebappServlet)servlet).free();
        servlet = null;
    }
1265168
public static void destroyEndpoints() {
        EndPointMgrImpl _this = (EndPointMgrImpl) getRef();
        synchronized (_this.endpoints) {
            _this.destroyEndpointMBeans();
            _this.endpoints.clear();
        }
    }
1051175
public void removeMarker(Marker marker) {
        if (markers != null && markers.contains(marker)) {
            markers.remove(marker);
        }
        marker.setMap(null);
    }
456028
public List<ServerRedirect> deleteServerMapping(int serverMappingId) {
        ArrayList<ServerRedirect> servers = new ArrayList<ServerRedirect>();
        try {
            JSONArray serverArray = new JSONArray(doDelete(BASE_SERVER + "/" + serverMappingId, null));
            for (int i = 0; i < serverArray.length(); i++) {
                JSONObject jsonServer = serverArray.getJSONObject(i);
                ServerRedirect server = getServerRedirectFromJSON(jsonServer);
                if (server != null) {
                    servers.add(server);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        return servers;
    }
351966
public void removeServer(InternalInstrumented<ServerStats> server) {
    remove(servers, server);
    ServerSocketMap prev = perServerSockets.remove(id(server));
    assert prev != null;
    assert prev.isEmpty();
  }
765780
@Command(name = "RemObjPolling", inTypeDesc = "Str[0]=Device name. Str[1]=Object type. Str[2]=Object name")
    public void removePolling(final String[] devices) throws DevFailed {
        xlogger.entry();
        if (devices.length < 3) {
            throw DevFailedUtils.newDevFailed(ExceptionMessages.WRONG_NR_ARGS, "Incorrect number of inout arguments");
        }
        final String deviceName = devices[0];
        final String type = devices[1];
        final String[] attributes = Arrays.copyOfRange(devices, 2, devices.length);
        for (final String attribute : attributes) {
            for (final DeviceClassBuilder deviceClass : classList) {
                if (deviceClass.containsDevice(deviceName)) {
                    final DeviceImpl dev = deviceClass.getDeviceImpl(deviceName);
                    if (type.equalsIgnoreCase(PolledObjectType.ATTRIBUTE.toString())) {
                        logger.debug("remove polling of attribute {} on device {}", attribute, deviceName);
                        dev.removeAttributePolling(attribute);
                    } else {
                        logger.debug("remove polling of command {} on device {}", attribute, deviceName);
                        dev.removeCommandPolling(attribute);
                    }
                }
            }
        }
        xlogger.exit();
    }
867752
def delete_mountpoints(self, paths=None, folder_ids=None):
        
        self.delete_folders(paths=paths, folder_ids=folder_ids, f_type='link')
1008885
public static synchronized void removeEndpoint(InetAddress ep)
    {
        String req = "DELETE FROM system.%s WHERE peer = ?";
        executeInternal(String.format(req, PEERS_CF), ep);
    }
723518
public boolean removeMapping(String hostName, String contextPath) {
        log.info("Remove mapping host: {} context: {}", hostName, contextPath);
        final String key = getKey(hostName, contextPath);
        log.debug("Remove mapping: {}", key);
        return (mapping.remove(key) != null);
    }
413760
public void removeInternalServlet(String name, String pathSpec,
      Class<? extends HttpServlet> clazz) {
    if(null == clazz) {
      return;
    }

    ServletHandler servletHandler = webAppContext.getServletHandler();
    List<ServletHolder> newServletHolders = new ArrayList<ServletHolder>();     
    List<ServletMapping> newServletMappings = new ArrayList<ServletMapping>();
    String clazzName = clazz.getName();
    Set<String> holdersToRemove = new HashSet<String>();

    //find all the holders that hold the servlet to be removed
    for(ServletHolder holder : servletHandler.getServlets()) {
      try{
        if(clazzName.equals(holder.getServlet().getClass().getName())
          && name.equals(holder.getName())) {
          holdersToRemove.add(holder.getName());
        } else {
          newServletHolders.add(holder);
        }      
      } catch(ServletException e) {
        LOG.error("exception in removeInternalServlet() when iterating through" +
                  "servlet holders" + StringUtils.stringifyException(e));
      }
    }    
  
    //if there is no holder to be removed, then the servlet does not exist in 
    //current context
    if(holdersToRemove.size() < 1) {
      return;
    }
  
    //only add the servlet mapping if it is not to be removed
    for(ServletMapping mapping : servletHandler.getServletMappings()) {
      //if the mapping's servlet is not to be removed, add to new mappings
      if(!holdersToRemove.contains(mapping.getServletName())) {
          newServletMappings.add(mapping);
      } else {
        String[] pathSpecs = mapping.getPathSpecs();
        boolean pathSpecMatched = false;
        if(pathSpecs != null && pathSpecs.length > 0) {
          for(String pathSpecInMapping: pathSpecs) {
            if(pathSpecInMapping.equals(pathSpec)) {
              pathSpecMatched = true;
              break;
            }
          }
        }
        //if the pathspec does not match, then add to the new mappings
        if(!pathSpecMatched) {
          newServletMappings.add(mapping);
        }
      }
    }
    
    servletHandler.setServletMappings(
        newServletMappings.toArray(new ServletMapping[newServletMappings.size()]));
    servletHandler.setServlets(
        newServletHolders.toArray(new ServletHolder[newServletHolders.size()]));
  }