Leave the specified multicast group at the specified interface using the specified source.
353297
public ChannelFuture leaveGroup(InetAddress multicastAddress,
                                    NetworkInterface networkInterface, InetAddress source) {
        if (DetectionUtil.javaVersion() < 7) {
            throw new UnsupportedOperationException();
        } else {
            if (multicastAddress == null) {
                throw new NullPointerException("multicastAddress");
            }

            if (networkInterface == null) {
                throw new NullPointerException("networkInterface");
            }

            synchronized (this) {
                if (memberships != null) {
                    List<MembershipKey> keys = memberships.get(multicastAddress);
                    if (keys != null) {
                        Iterator<MembershipKey> keyIt = keys.iterator();

                        while (keyIt.hasNext()) {
                            MembershipKey key = keyIt.next();
                            if (networkInterface.equals(key.networkInterface())) {
                                if (source == null && key.sourceAddress() == null ||
                                        source != null && source.equals(key.sourceAddress())) {
                                    key.drop();
                                    keyIt.remove();
                                }
                            }
                        }
                        if (keys.isEmpty()) {
                            memberships.remove(multicastAddress);
                        }
                    }
                }
            }
            return succeededFuture(this);
        }
    }
202356
public static synchronized void removeChannelGroup(String groupId) {
        try {
            if (_removeChannelGroup(groupId)) {
                save();
            }
        } catch (Exception ex) {
            Log.e(WonderPush.TAG, "Unexpected error while removing channel group " + groupId, ex);
        }
    }
885710
public function removeGroup(GroupInterface $group): void
    {
        if (!$group instanceof Production) {
            throw new Exception('Group type not supported.');
        }
        $this->groups->removeElement($group);
    }
1070615
public function leaveGroup(string $groupName, int $fd)
    {
        $this->createGroup($groupName)->leave($fd);
    }
268839
@Override
	public void removeByGroupId(long groupId) {
		for (CPInstance cpInstance : findByGroupId(groupId, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpInstance);
		}
	}
1060726
public void identity_group_group_DELETE(String group) throws IOException {
		String qPath = "/me/identity/group/{group}";
		StringBuilder sb = path(qPath, group);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1191560
private Group removeGroup(Session session, Group group, boolean broadcast) throws Exception
   {
      if (group == null)
      {
         throw new OrganizationServiceException("Can not remove group, since it is null");
      }

      Node groupNode = utils.getGroupNode(session, group);

      // need to minus one because of child "jos:memberships" node
      long childrenCount = ((ExtendedNode)groupNode).getNodesLazily(1).getSize() - 1;

      if (childrenCount > 0)
      {
         throw new OrganizationServiceException("Can not remove group till children exist");
      }

      if (broadcast)
      {
         preDelete(group);
      }

      removeMemberships(groupNode, broadcast);
      groupNode.remove();
      session.save();

      removeFromCache(group.getId());
      removeAllRelatedFromCache(group.getId());

      if (broadcast)
      {
         postDelete(group);
      }

      return group;
   }
542453
public void removeSource(GVRAudioSource audioSource)
    {
        synchronized (mAudioSources)
        {
            audioSource.setListener(null);
            mAudioSources.remove(audioSource);
        }
    }
1159673
public void leaveOccupiedPlace (BodyObject source)
    {
        Place oldloc = source.location;
        if (oldloc == null) {
            return; // nothing to do if they weren't previously in some location
        }

        PlaceManager pmgr = _plreg.getPlaceManager(oldloc.placeOid);
        if (pmgr == null) {
            log.warning("Body requested to leave no longer existent place?",
                        "boid", source.getOid(), "place", oldloc);
            return;
        }

        // tell the place manager that they're on the way out
        pmgr.bodyWillLeave(source);

        // clear out their location
        source.didLeavePlace(pmgr.getPlaceObject());
    }
492413
def down_host(trg_queue, host, user=None, group=None, mode=None):
    '''  '''
    down(trg_queue, user=user, group=group, mode=mode, host=host)
934954
def unjoin(self):
        

        self.avTransport.BecomeCoordinatorOfStandaloneGroup([
            ('InstanceID', 0)
        ])
        self._zgs_cache.clear()
        self._parse_zone_group_state()
1352991
def _do_leave(self, leave, in_port, msg):
        """"""
        datapath = msg.datapath
        parser = datapath.ofproto_parser

        self._mcast.setdefault(leave.address, {})
        if in_port in self._mcast[leave.address]:
            self._del_flow_entry(
                datapath, in_port, leave.address)
            del self._mcast[leave.address][in_port]
            actions = []
            for port in self._mcast[leave.address]:
                actions.append(parser.OFPActionOutput(port))
            if len(actions):
                self._set_flow_entry(
                    datapath, actions, self.server_port, leave.address)
            else:
                self._del_flow_entry(
                    datapath, self.server_port, leave.address)
1248594
private void leave(CompletableFuture<Void> future) {
    // Set a timer to retry the attempt to leave the cluster.
    leaveTimeout = raft.getThreadContext().schedule(raft.getElectionTimeout(), () -> {
      leave(future);
    });

    // Attempt to leave the cluster by submitting a LeaveRequest directly to the server state.
    // Non-leader states should forward the request to the leader if there is one. Leader states
    // will log, replicate, and commit the reconfiguration.
    raft.getRaftRole().onLeave(LeaveRequest.builder()
        .withMember(getMember())
        .build()).whenComplete((response, error) -> {
          // Cancel the leave timer.
          cancelLeaveTimer();

          if (error == null && response.status() == RaftResponse.Status.OK) {
            Configuration configuration = new Configuration(response.index(), response.term(), response.timestamp(), response.members());

            // Configure the cluster and commit the configuration as we know the successful response
            // indicates commitment.
            configure(configuration).commit();
            future.complete(null);
          } else {
            // Reset the leave timer.
            leaveTimeout = raft.getThreadContext().schedule(raft.getElectionTimeout(), () -> {
              leave(future);
            });
          }
        });
  }
807582
def depart(self):
        
        unit = hookenv.remote_unit()
        self.units.remove(unit)
        if self.units:
            unitdata.kv().set(self.key, self.serialize(self))
        else:
            unitdata.kv().unset(self.key)
1106967
@Override
	public void removeByGroupId(long groupId) {
		for (CommerceAvailabilityEstimate commerceAvailabilityEstimate : findByGroupId(
				groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(commerceAvailabilityEstimate);
		}
	}
1259559
def _do_timeout_for_leave(self, timeout, datapath, dst, in_port):
        """"""
        parser = datapath.ofproto_parser
        dpid = datapath.id

        hub.sleep(timeout)
        outport = self._to_querier[dpid]['port']

        if self._to_hosts[dpid][dst]['ports'][in_port]['out']:
            return

        del self._to_hosts[dpid][dst]['ports'][in_port]
        self._del_flow_entry(datapath, in_port, dst)
        actions = []
        ports = []
        for port in self._to_hosts[dpid][dst]['ports']:
            actions.append(parser.OFPActionOutput(port))
            ports.append(port)

        if len(actions):
            self._send_event(
                EventMulticastGroupStateChanged(
                    MG_MEMBER_CHANGED, dst, outport, ports))
            self._set_flow_entry(
                datapath, actions, outport, dst)
            self._to_hosts[dpid][dst]['leave'] = None
        else:
            self._remove_multicast_group(datapath, outport, dst)
            del self._to_hosts[dpid][dst]
873492
public void removeGroup(int groupId) {
        PreparedStatement statement = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "DELETE FROM " + Constants.DB_TABLE_GROUPS
                    + " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setInt(1, groupId);
            statement.executeUpdate();
            statement.close();

            statement = sqlConnection.prepareStatement(
                "DELETE FROM " + Constants.DB_TABLE_OVERRIDE +
                    " WHERE " + Constants.OVERRIDE_GROUP_ID + " = ?"
            );

            statement.setInt(1, groupId);
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
        removeGroupIdFromTablePaths(groupId);
    }