Delete this channel.

@throws AuthenticationRequiredException
@throws NchanException
354541
public function delete(): void
    {
        $response = $this->client->delete(
            new Request(
                $this->channelUrl,
                [
                    'Accept' => 'application/json'
                ]
            )
        );

        if (!in_array($response->statusCode(), [Response::OK, RESPONSE::NOT_FOUND])) {
            throw new NchanException(
                sprintf(
                    'Unable to delete channel. Maybe the channel does not exists. HTTP status code was %s.',
                    $response->statusCode()
                )
            );
        }
    }
479541
public function delete(AuthCodeEntity $token)
    {
        $this->getDbConnection()->delete('oauth_auth_code_scope', [
            'auth_code' => $token->getId()
        ]);

        $this->getDbConnection()->delete('oauth_auth_code', [
            'auth_code' => $token->getId()
        ]);
    }
143045
public function delete(AuthCodeEntity $token)
    {
        $this->getConnection()->table('oauth_auth_codes')
        ->where('oauth_auth_codes.id', $token->getId())
        ->delete();
    }
435609
public static ns_ssl_certkey delete(nitro_service client, ns_ssl_certkey resource) throws Exception
	{
		resource.validate("delete");
		return ((ns_ssl_certkey[]) resource.delete_resource(client))[0];
	}
1025212
@Override
    public void delete(IEntityLock lock) throws LockingException {
        Map m = getLockCache(lock.getEntityType());
        synchronized (m) {
            m.remove(getCacheKey(lock));
        }
    }
863966
public HttpClient delete(String url) throws HelloSignException {
        request = new HttpDeleteRequest(url, auth);
        request.execute();
        return this;
    }
1163544
@DELETE
    @Path("/{name}")
    public Response delete(@Auth final DbCredential credential, @PathParam("name") final String name){
        if(!credential.getRoles().contains(DbCredential.AvailableRoles.DATA_DELETER)){
            throw new WebApplicationException(Response.status(Response.Status.UNAUTHORIZED).build());
        }

        LOG.info("Got a delete organization request.");
        getOrganizationHandler().deleteOrganization(name);

        return Response.ok("done").build();
    }
188564
public void clearSingleSignOn(String username)
    {
        synchronized(_ssoId2Principal)
        {
            Object ssoID=_ssoUsername2Id.remove(username);
            Object principal=_ssoId2Principal.remove(ssoID);
            _ssoPrincipal2Credential.remove(principal);
        }        
    }
1245101
@Override
    public void removeAuthorization(FoxHttpAuthorizationScope foxHttpAuthorizationScope, FoxHttpAuthorization foxHttpAuthorization) {
        ArrayList<FoxHttpAuthorization> authorizations = foxHttpAuthorizations.get(foxHttpAuthorizationScope.toString());
        ArrayList<FoxHttpAuthorization> cleandAuthorizations = new ArrayList<>();
        for (FoxHttpAuthorization authorization : authorizations) {
            if (authorization.getClass() != foxHttpAuthorization.getClass()) {
                cleandAuthorizations.add(authorization);
            }
        }
        foxHttpAuthorizations.put(foxHttpAuthorizationScope.toString(), cleandAuthorizations);
    }
468768
public String delete(String url) throws AuthenticationException, ApiException {
		return performRequest(url, "DELETE", null, null, null);
	}
1116883
@Deprecated
	public void delete(Collection<Channel.Builder> channels)
			throws ChannelFinderException {
		for (Channel.Builder channel : channels) {
			deleteChannel(channel.build().getName());
		}
	}
733056
void removeClientChannel(HttpRoute httpRoute, Http2ClientChannel http2ClientChannel) {
        EventLoopPool.PerRouteConnectionPool perRouteConnectionPool = fetchPerRoutePool(httpRoute,
                                                                                        http2ClientChannel.getChannel()
                                                                                            .eventLoop());
        if (perRouteConnectionPool != null) {
            perRouteConnectionPool.removeChannel(http2ClientChannel);
        }
    }
29959
private String _delete(nitro_service service, String req_args) throws Exception
	{
		StringBuilder responseStr = new StringBuilder();
		HttpURLConnection httpURLConnection = null;
		try
		{
			String urlstr;
			String ipaddress = service.get_ipaddress();
			String version = service.get_version();
			String sessionid = service.get_sessionid();
			String objtype = get_object_type();
			String protocol = service.get_protocol();
			// build URL
			urlstr = protocol + "://" + ipaddress + "/nitro/" + version + "/config/" + objtype;

			String name = this.get_object_id();
			if (name != null && name.length() > 0)
			{
				urlstr = urlstr + "/" + nitro_util.encode(nitro_util.encode(name));
			}

			/*if(req_args != null && req_args.length() > 0)
			{
				urlstr = urlstr + "?args=" + req_args;
			}*/

			URL url = new URL(urlstr);
			httpURLConnection = (HttpURLConnection) url.openConnection();

			httpURLConnection.setRequestMethod("DELETE");

			if(sessionid != null)
			{
				httpURLConnection.setRequestProperty("Cookie", "SESSID=" + nitro_util.encode(sessionid));
				httpURLConnection.setRequestProperty("Accept-Encoding", "gzip, deflate");
			}
			
			if (httpURLConnection instanceof HttpsURLConnection)
			{
				SSLContext sslContext = SSLContext.getInstance("SSL");
				//we are using an empty trust manager, because MPS currently presents
				//a test certificate not issued by any signing authority, so we need to bypass
				//the credentials check
				sslContext.init(null, new TrustManager[]{new EmptyTrustManager()}, null);
				SocketFactory sslSocketFactory = sslContext.getSocketFactory();

				HttpsURLConnection secured = (HttpsURLConnection) httpURLConnection;
				secured.setSSLSocketFactory((SSLSocketFactory)sslSocketFactory);
				secured.setHostnameVerifier(new EmptyHostnameVerifier());
			}

			InputStream input = httpURLConnection.getInputStream();
			String contentEncoding = httpURLConnection.getContentEncoding();
			//	get correct input stream for compressed data:
			if (contentEncoding != null)
			{
				if(contentEncoding.equalsIgnoreCase("gzip"))
					input = new GZIPInputStream(input); //reads 2 bytes to determine GZIP stream!
				else if(contentEncoding.equalsIgnoreCase("deflate"))
					input = new InflaterInputStream(input);
			}

			int numOfTotalBytesRead;
			byte [] buffer = new byte[1024];
			while ((numOfTotalBytesRead = input.read(buffer, 0, buffer.length)) != -1)
			{
				responseStr.append(new String(buffer, 0, numOfTotalBytesRead));
			}

			httpURLConnection.disconnect();
			input.close();
		}
		catch (MalformedURLException mue)
		{
			System.err.println("Invalid URL");
		}
		catch (IOException ioe)
		{
			System.err.println("I/O Error - " + ioe);
		}
		catch(Exception e)
		{
			System.err.println("Error - " + e);
		}		
		
		return responseStr.toString();	
	}
941310
synchronized void removeCredential(String accountId) throws IOException {
        DataStore<StoredCredential> sc = StoredCredential.getDefaultDataStore(dataStoreFactory);
        sc.delete(accountId);
        calendarService = null;
        geoService = null;
    }
1148364
def delete_channel_cb(self, viewer, channel):
        """"""
        chname = channel.name
        del self.name_dict[chname]

        # Unhighlight
        un_hilite_set = set([])
        for path in self._hl_path:
            if path[0] == chname:
                un_hilite_set.add(path)
        self._hl_path -= un_hilite_set

        if self.gui_up:
            self.recreate_toc()

        self._rebuild_channels()
662155
public void remove(String fqn) {
        awaitRunning();
        try {
            channel.send(new Message(null, new Request(Request.REMOVE, fqn)));
        } catch (Exception ex) {
            LOG.error("failure bcasting REMOVE request", ex);
        }
    }
252517
public void unsubscribe(String channel) {
		ChannelSubscription subscribedChannel = subscribedChannels.get(channel);

		if (isUnsubscribeValid(channel, subscribedChannel)) {
			subscribedChannel.setSubscribeOnReconnected(false);
			unsubscribe(channel, true, subscribedChannel.isWithNotification());
		}

		//subscribedChannels.remove(channel);
	}