Removes the group's containers and sub groups from the layer
@param {WireIt.Group} The group to remove
@param {WireIt.Layer} The layer to remove them from
551453
function(group, layer)
	{
	    group.collapsing = true;
	    
	    if (lang.isValue(group.groupContainer))
		layer.removeContainer(group.groupContainer);
	    else
	    {
		for (var i in group.containers)
		    layer.removeContainer(group.containers[i])
		    
		for (var i in group.groups)
		    WireIt.GroupUtils.removeGroupFromLayer(group.groups[i], layer);
	    }
	    group.collapsing = false;
	}
633711
function(group) {
		this.deselectGroup();
		this.selectedGroup = group;
		WireIt.GroupUtils.applyToContainers(this.selectedGroup, true, function(c) { c.highlight(); });
   }
326862
function(container) {
      var index = WireIt.indexOf(container, this.containers);
      if( index != -1 ) {
	  
	container.remove();
	    
        this.containers[index] = null;
        this.containers = WireIt.compact(this.containers);
      
	this.eventRemoveContainer.fire(container);

	this.eventChanged.fire(this);
      }
   }
733850
function (layer) {
		var $canvas, handle, h;
		if (layer._handles) {
			$canvas = $(this);
			// Remove handles from layer
			for (h = 0; h < layer._handles.length; h += 1) {
				handle = layer._handles[h];
				$canvas.removeLayer(handle);
			}
			layer._handles.length = 0;
		}
	}
444573
function () {
		var element = this.element,
			childNodes = element.childNodes,
			i = childNodes.length;

		while (i--) {
			element.removeChild(childNodes[i]);
		}
	}
857539
private void remove(Integer layer, Refreshable refreshable)
    {
        final Collection<Refreshable> refreshables = getLayer(layer);
        refreshables.remove(refreshable);
        if (refreshables.isEmpty())
        {
            indexs.remove(layer);
        }
    }
1327645
public void removeLayer(Layer layer) {
		if (layers.contains(layer)) {
			layers.remove(layer);
			mapInfo.getLayers().remove(layer.getLayerInfo());
			handlerManager.fireEvent(new MapModelChangedEvent(this));
		}
	}
898148
function(element) {
        element = OpenLayers.Util.getElement(element);
        element.parentNode.removeChild(element);
    }
1001224
def remove_from_group(server_context, user_ids, group_id, container_path=None):
    
    return __make_security_group_api_request(server_context, 'removeGroupMember.api', user_ids,
                                             group_id, container_path)
842857
protected boolean removeLayer(Layer layer) {
		int index = getLayerIndex(layer);
		if (index >= 0) {
			//contentPanel.remove(index);
			view.removeWidget(index);

			return true;
		}
		return false;
	}
1119527
def removeNestedGroups(node):
    
    global _num_elements_removed
    num = 0

    groupsToRemove = []
    # Only consider <g> elements for promotion if this element isn't a <switch>.
    # (partial fix for bug 594930, required by the SVG spec however)
    if not (node.nodeType == Node.ELEMENT_NODE and node.nodeName == 'switch'):
        for child in node.childNodes:
            if child.nodeName == 'g' and child.namespaceURI == NS['SVG'] and len(child.attributes) == 0:
                # only collapse group if it does not have a title or desc as a direct descendant,
                for grandchild in child.childNodes:
                    if grandchild.nodeType == Node.ELEMENT_NODE and grandchild.namespaceURI == NS['SVG'] and \
                            grandchild.nodeName in ['title', 'desc']:
                        break
                else:
                    groupsToRemove.append(child)

    for g in groupsToRemove:
        while g.childNodes.length > 0:
            g.parentNode.insertBefore(g.firstChild, g)
        g.parentNode.removeChild(g)
        _num_elements_removed += 1
        num += 1

    # now recurse for children
    for child in node.childNodes:
        if child.nodeType == Node.ELEMENT_NODE:
            num += removeNestedGroups(child)
    return num
1134981
async def remove(gc: GroupControl, slaves):
    """"""
    click.echo("Removing from existing group: %s" % slaves)
    click.echo(await gc.remove(slaves))
1080905
function() {
        this.layer  = null;
        this.bounds = null;
        this.size = null;
        this.position = null;
        
        if (this.eventListeners) {
            this.events.un(this.eventListeners);
        }
        this.events.destroy();
        this.eventListeners = null;
        this.events = null;
    }
1209531
function destroy() {
                this.onDestroy();
                this.eventBus.clear();
                while (this._events.length > 0) {
                    this._events.shift().remove();
                }

                while (this._globalEvents.length > 0) {
                    this._globalEvents.shift().remove();
                }

                _destroy(this.children);

                if (this.elGroup !== undefined && this.el !== undefined) {
                    this.elGroup.delete(this.el);
                }
                if (this.root && this.root.remove) {
                    this.root.remove();
                }

                delete this.el;
            }
1023687
function(layer) {
        var target;
        for(var i=this.targets.length-1; i>=0; --i) {
            target = this.targets[i];
            if(target.layer === layer) {
                this.removeTarget(target);
            }
        }
    }
354393
function _updateLayerGroups($canvas, data, layer, props) {
	var groupMap = data.layer.groups,
		group, groupName, g,
		index, l;

	// If group name is not changing
	if (!props) {

		props = layer;

	} else {

		// Remove layer from all of its associated groups
		if (props.groups !== undefined && layer.groups !== null) {
			for (g = 0; g < layer.groups.length; g += 1) {
				groupName = layer.groups[g];
				group = groupMap[groupName];
				if (group) {
					// Remove layer from its old layer group entry
					for (l = 0; l < group.length; l += 1) {
						if (group[l] === layer) {
							// Keep track of the layer's initial index
							index = l;
							// Remove layer once found
							group.splice(l, 1);
							break;
						}
					}
					// Remove layer group entry if group is empty
					if (group.length === 0) {
						delete groupMap[groupName];
					}
				}
			}
		}

	}

	// Add layer to new group if a new group name is given
	if (props.groups !== undefined && props.groups !== null) {

		for (g = 0; g < props.groups.length; g += 1) {

			groupName = props.groups[g];

			group = groupMap[groupName];
			if (!group) {
				// Create new group entry if it doesn't exist
				group = groupMap[groupName] = [];
				group.name = groupName;
			}
			if (index === undefined) {
				// Add layer to end of group unless otherwise stated
				index = group.length;
			}
			// Add layer to its new layer group
			group.splice(index, 0, layer);

		}

	}
}
950985
def remove_group(self, group):
        
        if not isinstance(group, Group):
            raise TypeError("group must be Group")
        if group not in self.groups:
            raise ValueError("Group doesn't exist / is not bound to this database.")
        
        #save num entries and children before removal to avoid for loop problems
        num_entries = len(group.entries)
        for i in xrange(num_entries):
            self.remove_entry(group.entries[0])

        # Recurse down to remove sub-groups
        num_children = len(group.children)
        for i in xrange(num_children): # We may need to copy this to avoid CME (see below)
            self.remove_group(group.children[0])
        
        # Finally remove group from the parent's list.
        group.parent.children.remove(group) # Concurrent modification exception? Parent in recursive stack is iterating ...
        self.groups.remove(group)