/*
Delete your campaigns.
@param {Object} data contains json objects as a key value pair from HashMap.
@options data {Integer} id: Id of campaign to be deleted [Mandatory]
343026
public String delete_campaign(Map<String, Object> data) {
        String id = data.get("id").toString();
        return delete("campaign/" + id, EMPTY_STRING);
    }
1308166
function(data) {

            var map = _map,
                key;

            if (map && data) {
                for (key in data) {
                    if (key && data.hasOwnProperty(key)) {
                        _map[key] = data[key];
                    }
                }
            }

        }
693307
function(id) {
    // get embed keys as a separate array to enable deleting keys in map
    var ids = Object.keys(embeds);
    for(var i = 0; i < ids.length; ++i) {
      var next = ids[i];
      if(next in embeds && _isObject(embeds[next].parent) &&
        embeds[next].parent['@id'] === id) {
        delete embeds[next];
        removeDependents(next);
      }
    }
  }
1353484
protected function delete($data = null)
    {
        if ($this->hasMethod('__delete') && is_callable([$this, '__delete'])) {
            return $this->__delete($data);
        }

        // notify observers about new data
        $this->notify();
    }
144248
function(id, callback) {
    var self = this;
    
    if (typeof id == 'number' || typeof id == 'string' || id instanceof Array || id instanceof ObjectID) {

      this.driver.deleteById({
        collection: this.context,
        _id: id
      }, function(err) {
        callback.call(self, err);
      });
      
    } else if (id && typeof id == 'object') {
      
      var o = id;
      
      this.driver.deleteWhere({
        collection: this.context,
        condition: o
      }, function(err) {
        callback.call(self, err);
      });
      
    } else {
      callback.call(self, new Error(util.format("%s: Wrong value for `id` parameter", this.className)));
    }
  }
1176440
def delete(*args)
      arguments(args, required: [:card_id])
      params = arguments.params

      params["accept"] ||= ::Github::Client::Projects::PREVIEW_MEDIA

      delete_request("/projects/columns/cards/#{arguments.card_id}", params)
    end
515673
public function remove($data)
    {
        $data = $this->fetchRemainingSegment($this->data, $data);
        if (! is_null($data)) {
            $this->set($data);
        }
    }
80055
public function RemoveAnnouncements($Data) {
      $Result =& $Data->Result();
      $Unset = FALSE;
      
      foreach($Result as $Key => &$Discussion) {
         if (isset($this->_AnnouncementIDs)) {
            if (in_array($Discussion->DiscussionID, $this->_AnnouncementIDs)) {
               unset($Result[$Key]);
               $Unset = TRUE;
            }
         } elseif ($Discussion->Announce && $Discussion->Dismissed == 0) {
            // Unset discussions that are announced and not dismissed
            unset($Result[$Key]);
            $Unset = TRUE;
         }
      }
      if ($Unset) {
         // Make sure the discussions are still in order for json encoding.
         $Result = array_values($Result);
      }
   }
702032
public static void delete(CallInfo callInfo, DataSet data) {
    Table table = asTable(data.getSource()); 
    List<String> keyColumns = table.getKeyColumns();
    
    if (keyColumns.isEmpty()) {
      throw new InvalidOperationException("No key columns defined.");
    }
    
    List<String> tableColumns = table.getColumns();
    int param = 0;
    int[] paramIdx = new int[tableColumns.size()];
    Iterator<String> itr = keyColumns.iterator();
    StringBuilder sql = new StringBuilder();
    String kcol = itr.next();
    
    paramIdx[tableColumns.indexOf(kcol)] = ++param;
    sql.append(DELETE_FROM_)
       .append(table.getName())
       .append(WHERE_)
       .append(kcol)
       .append("=?");
    
    while (itr.hasNext()) {
      kcol = itr.next();
      paramIdx[tableColumns.indexOf(kcol)] = ++param;
      sql.append(AND_)
         .append(kcol)
         .append("=?");
    }
   
    table.setDirtyStatus(true);
    dataSetOperation(callInfo, table, data, sql.toString(), paramIdx);
  }
126414
function( data ){

            // interpred data as either dom node or event data
            var el = (data instanceof PIXI.Graphics && data) || (data.body && data.body.view);

            if ( el ){
                // remove view from dom
                this.stage.removeChild( el );
            }

            return this;
        }
1311086
function deletePolicy (params, cb) {
      let promise = null
      if (typeof cb !== 'function') [promise, cb] = asyncify()

      const { id, organizationId } = params
      const tasks = [
        (job, next) => {
          Joi.validate({ id, organizationId }, validationRules.deletePolicy, (err) => {
            if (err) return next(Boom.badRequest(err))

            next()
          })
        },
        (job, next) => {
          job.id = id
          job.organizationId = organizationId
          next()
        },
        removePolicyFromUsers,
        removePolicyFromTeams,
        removePolicyFromOrganizations,
        removePolicy
      ]

      db.withTransaction(tasks, (err, res) => {
        if (err) return cb(err)
        cb()
      })

      return promise
    }
345651
def delete(self, dataset_identifier, row_id=None, content_type="json"):
        '''
        
        '''
        if row_id:
            resource = _format_new_api_request(dataid=dataset_identifier, row_id=row_id,
                                               content_type=content_type)
        else:
            resource = _format_old_api_request(dataid=dataset_identifier,
                                               content_type=content_type)

        return self._perform_request("delete", resource)
84860
@Override
  public void delete(DBIDRef id) {
    assert (!ids.contains(id)) : "Object still in DBIDs.";
    if(!(content instanceof WritableDataStore)) {
      throw new AbortException("Data is stored in a non-writable data store. Modifications are not possible.");
    }
    for(It<Index> it = this.getHierarchy().iterDescendants(this).filter(Index.class); it.valid(); it.advance()) {
      if(!(it.get() instanceof DynamicIndex)) {
        throw new AbortException("A non-dynamic index was added to this database. Modifications are not allowed, unless this index is removed.");
      }
      ((DynamicIndex) it.get()).delete(id);
    }
    ((WritableDataStore<O>) content).delete(id);
  }
194920
public function delete(array $data)
  {
    foreach ($data as $key => $id)
    {
      $CostCenter = $this->byId($id);
      $CostCenter->delete();
    }
    // $this->CostCenter->destroy($data);

    return true;
  }
1112011
public void removeIndex(ValidationData data) {
        for (ValidationDataIndex idx : this.idxs) {
            ValidationIndexUtil.removeIndexData(data, idx);
        }
    }
764044
@Deprecated
    public void removeData(C data) {
        Preconditions.checkState(mGroupBasicAdapter != null, "Must call bindView() first");
        this.mGroupBasicAdapter.removeGroup(data);
    }
361922
function(id, key) {
      // if key is defined and of type string....
      if(typeof key !== 'undefined' && typeof key === 'string') {

        // if id/key exists...
        if(memStore[id] && memStore[id][key]) {
          delete memStore[id][key];
        }

        return true;
      }

      // else if key is not defined...
      else if(typeof key === 'undefined') {
        delete memStore[id];
        return true;
      }

      // else key defined, but not of type string...
      else {
        throw new Error('invalid data type or missing value');
        return false;
      }
    }