Deletes a key for a particular group

@param mixed  $mKey      The key to delete
@param string $sGrouping The key's grouping

@return bool
337289
public function delete($mKey, $sGrouping)
    {
        $oDb = Factory::service('Database');
        $oDb->trans_begin();

        if (is_array($mKey)) {

            foreach ($mKey as $sKey) {
                $this->doDelete($sKey, $sGrouping);
            }

        } else {

            $this->doDelete($mKey, $sGrouping);
        }

        if ($oDb->trans_status() === false) {

            $oDb->trans_rollback();

            return false;

        } else {

            $oDb->trans_commit();

            return true;
        }
    }
1100502
public function delete($key, $group = self::DEFAULT_GROUP) {
        $this->repository
            ->deleteByKey($key, $group);

        return true;
    }
135190
function(sGroup) {
        this.logger.log("Removing from group: " + sGroup);
        if (this.groups[sGroup]) {
            delete this.groups[sGroup];
        }

        this.DDM.removeDDFromGroup(this, sGroup);
    }
545296
public void deleteGroup(String key, IPerson deleter) {

        if (!canDeleteGroup(deleter, key)) {
            throw new RuntimeAuthorizationException(
                    deleter, IPermission.DELETE_GROUP_ACTIVITY, key);
        }

        log.info("Deleting group with key " + key);

        // find the current version of this group entity
        IEntityGroup group = GroupService.findGroup(key);

        // remove this group from the membership list of any current parent
        // groups
        for (IEntityGroup parent : group.getParentGroups()) {
            parent.removeChild(group);
            parent.updateMembers();
        }

        // delete the group
        group.delete();
    }
1295970
def delete_group(self, name):
        

        group = self.get_group(name)

        method, url = get_URL('group_delete')

        payload = {
            'apikey': self.config.get('apikey'),
            'logintoken': self.session.cookies.get('logintoken'),
            'contactgroupid': group['contactgroupid']
            }

        res = getattr(self.session, method)(url, params=payload)

        if res.status_code == 200:
            return True

        hellraiser(res)
1034873
@Override
	public String remove(Object key) {
		return this.groupedMap.remove(DEFAULT_GROUP, Convert.toStr(key));
	}
15503
public function deleteEntryByKey($key)
    {
        if (isset($this->array['Key2Tags'][$key])) {
            unset($this->array['Key2Tags'][$key]);

            foreach ($this->array['Tags2Key'] as $tag => $tagKeys) {
                if (isset($tagKeys[$key])) {
                    unset($this->array['Tags2Key'][$tag][$key]);
                }
            }
        }

        return false;
    }
872676
def servicegroup_delete(sg_name, **connection_args):
    '''
    
    '''
    ret = True
    sg = _servicegroup_get(sg_name, **connection_args)
    if sg is None:
        return False
    nitro = _connect(**connection_args)
    if nitro is None:
        return False
    try:
        NSServiceGroup.delete(nitro, sg)
    except NSNitroError as error:
        log.debug('netscaler module error - NSServiceGroup.delete() failed: %s', error)
        ret = False
    _disconnect(nitro)
    return ret
649882
protected function doSet($sKey, $sGrouping, $mValue, $bEncrypt)
    {
        $sValue   = json_encode($mValue);
        $bEncrypt = (bool) $bEncrypt;

        if ($bEncrypt) {
            $oEncrypt = Factory::service('Encrypt');
            $sValue   = $oEncrypt->encode($sValue);
        }

        $oDb = Factory::service('Database');
        $oDb->where('key', $sKey);
        $oDb->where('grouping', $sGrouping);

        if ($oDb->count_all_results($this->sTable)) {

            $oDb->set('value', $sValue);
            $oDb->set('is_encrypted', $bEncrypt);
            $oDb->where('grouping', $sGrouping);
            $oDb->where('key', $sKey);
            $oDb->update($this->sTable);

        } else {

            $oDb->set('value', $sValue);
            $oDb->set('grouping', $sGrouping);
            $oDb->set('key', $sKey);
            $oDb->set('is_encrypted', $bEncrypt);
            $oDb->insert($this->sTable);
        }
    }
44284
public void delete(String job, Map<String, String> groupingKey) throws IOException {
    doRequest(null, job, groupingKey, "DELETE");
  }
422106
public function remove_keyword_group ($key) {
        //Remove the keyword group internally
        unset($this->language_data['KEYWORDS'][$key]);
        unset($this->lexic_permissions['KEYWORDS'][$key]);
        unset($this->language_data['CASE_SENSITIVE'][$key]);
        unset($this->language_data['STYLES']['KEYWORDS'][$key]);

        //NEW in 1.0.8
        unset($this->language_data['CACHED_KEYWORD_LISTS'][$key]);
    }
827007
public function removeGroup($groupName)
    {
        if (true === is_string($groupName) && true === in_array($groupName, $this->groups)) {
            foreach (array_keys($this->groups, (string)$groupName, true) as $key) {
                unset($this->groups[$key]);
            }
        }
        return $this;
    }
1331686
public void removeGroup(String group) {

        if (m_fieldsByGroup.get(group) != null) {
            List<I_CmsFormField> fieldsToRemove = new ArrayList<I_CmsFormField>(m_fieldsByGroup.get(group));
            for (I_CmsFormField field : fieldsToRemove) {
                removeField(field);
            }
        }
        m_fieldsByGroup.removeAll(group);
    }
519731
public static CommerceUserSegmentEntry removeByG_K(long groupId, String key)
		throws com.liferay.commerce.user.segment.exception.NoSuchUserSegmentEntryException {
		return getPersistence().removeByG_K(groupId, key);
	}
888151
@Override
    public void deleteGroup(IEntityGroup group) throws GroupsException {
        throwExceptionIfNotInternallyManaged();
        synchronizeGroupMembersOnDelete(group);
        getGroupStore().delete(group);
        if (cacheInUse()) {
            cacheRemove(group);
        }
    }
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;
   }
414482
public function delete(string $sKey): bool
    {
        if ($this->exists($sKey)) {
            return @unlink($this->prepKey($sKey));
        } else {
            return false;
        }
    }