Deletes an index from the Table.  Can be used to drop and rebuild an index,
           or to convert a non-unique index to a unique index, or vice versa.
           @param attr: name of an indexed attribute
           @type attr: string
174871
def delete_index(self, attr):
        
        if attr in self._indexes:
            del self._indexes[attr]
            self._uniqueIndexes = [ind for ind in self._indexes.values() if ind.is_unique]
        return self
100459
def clean_attribute(value)
        if value.kind_of?(Hash)
          value.delete_if { |key, value| clean_attribute(value) }.empty?
        elsif value.kind_of?(Array)
          value.delete_if { |value| clean_attribute(value) }.empty?
        else
          value.to_s.strip.empty?
        end
      end
398170
def destroy_key attribute, key
      raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
      new_value = send(attribute)
      new_value.delete(key.to_s)
      send("#{attribute}=", new_value)
      self
    end
299620
function (attr, attrName) {
            if (_.isObject(attr) && !_.isDate(attr) && !_.isBoolean(attr) && !_.isString(attr) && !_.isNumber(attr) && !_.isFunction(attr) && !_.isRegExp(attr) && !_.isArray(attr)) {
                //attr = _removeAttributes();
                for (var aIndex in attr) {
                    attr[aIndex] = _removeAttributes(attr[aIndex], aIndex);
                }
                return attr;
            }
            else {
                if (_.indexOf(allowedAttributes, attrName) != -1) {
                    if (_.isFunction(attr)) {
                        attr = _functionName(attr);
                    }

                    return attr;
                }
                else {
                    return;
                }
            }
        }
212397
private void validateDeleteAllowed(Attribute attr) {
    String attrIdentifier = attr.getIdentifier();
    if (systemEntityTypeRegistry.hasSystemAttribute(attrIdentifier)) {
      throw new SystemMetadataModificationException();
    }
  }
1045726
def remove_attribute(attribute)
      sa = standard_attribute(attribute)
      # if the attribute is local, then delete it, otherwise filter out the superclass attribute
      sp = @local_prop_hash.delete(sa)
      if sp then
        # clear the inverse, if any
        clear_inverse(sp)
        # remove from the mandatory attributes, if necessary
        @local_mndty_attrs.delete(sa)
        # remove from the attribute => metadata hash
        @local_std_prop_hash.delete_if { |aliaz, pa| pa == sa }
      else
        # Filter the superclass hashes.
        anc_prop_hash = @prop_hash.components[1]
        @prop_hash.components[1] = anc_prop_hash.filter_on_key { |pa| pa != attribute }
        anc_alias_hash = @alias_std_prop_map.components[1]
        @alias_std_prop_map.components[1] = anc_alias_hash.filter_on_key { |pa| pa != attribute }
      end
      logger.debug { "Removed the #{qp} #{attribute} property." }
    end
1155965
def DeleteIndex(self, index):
        
        to_remove = None
        for i in self.Items:
            if i.index == index:
                to_remove = i

        if to_remove:
            self.Items.remove(to_remove)
710523
function (attrName, attrVal) {
            if (!attrName) {
                delete this.attrs;
                return;
            }
            if(!this.attrs){
                this.attrs = {};
            }
            if (utils.isObject(attrName)) {
                for (var a in attrName) {
                    if (!attrName[a]) {
                        delete this.attrs[a]
                    } else {
                        this.attrs[a.toLowerCase()] = attrName[a];
                    }
                }
            } else {
                if (!attrVal) {
                    delete this.attrs[attrName]
                } else {
                    this.attrs[attrName.toLowerCase()] = attrVal;
                }

            }
        }
597209
public void delete(String name) throws IOException {
        if (name.equalsIgnoreCase(VERSION)) {
            version = V1;
        } else {
            throw new IOException("Attribute name not recognized by " +
                                  "CertAttrSet: CertificateVersion.");
        }
    }
987636
def removeAttributeNode(self, attr: Attr) -> Optional[Attr]:
        """"""
        return self.attributes.removeNamedItem(attr)
1006704
public synchronized void delete(String name) {
        if (isEmpty(name)) {
            indexedProps.remove(name);
        } else {
            synchronized (context) {
                int scope = context.getAttributesScope(name);
                if (scope != -1) {
                    context.removeAttribute(name, scope);
                }
            }
        }
    }
928951
function(attr, options) {
      if (!(attr in this.attributes)) return this;
      options || (options = {});
      var value = this.attributes[attr];

      // Run validation.
      var validObj = {};
      validObj[attr] = void 0;
      if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;

      // Remove the attribute.
      delete this.attributes[attr];
      delete this._escapedAttributes[attr];
      if (attr == this.idAttribute) delete this.id;
      this._changed = true;
      if (!options.silent) {
        this.trigger('change:' + attr, this, void 0, options);
        this.change(options);
      }
      return this;
    }
836180
def delete_at(index = @entries.index { |e| e })
      yield(@entries[index]) if block_given?
      if size > 1
        entries = @entries.dup
        child = @children[index]
        if child
          children = @children.dup
          children[index] = child.delete_at do |entry|
            entries[index] = entry
          end
        else
          entries[index] = nil
        end
        Trie.new(@significant_bits, @size - 1, entries, children || @children)
      end
    end
452547
public void remove_attribute(final String attname) throws DevFailed {
	// Remove property in database
	if (Util._UseDb) {
	    final DeviceProxy dev = new DeviceProxy(device_name);
	    final DbAttribute da = dev.get_attribute_property(attname);
	    dev.delete_attribute_property(da);

	}
	dev_attr.remove_attribute(attname);
    }
659976
public void delete_attribute_property(final DeviceProxy deviceProxy,
                                          final DbAttribute attr) throws DevFailed {
        checkIfUseDb(deviceProxy, "delete_attribute_property()");

        if (deviceProxy.getDb_dev() == null) {
            deviceProxy.setDb_dev(new DbDevice(deviceProxy.devname, deviceProxy.url.host,
                deviceProxy.url.strPort));
        }
        checkIfTango(deviceProxy, "delete_attribute_property");
        deviceProxy.getDb_dev().delete_attribute_property(attr);
    }
1244064
def delete(attribute, type = nil, **options)
      attribute, type, options = normalize_arguments(attribute, type, options)
      matches = where(attribute, type, options)
      matches.each do |error|
        @errors.delete(error)
      end
      matches.map(&:message)
    end
1320793
public void delete(String name)
    throws CertificateException, IOException {
        X509AttributeName attrName = new X509AttributeName(name);

        int attr = attributeMap(attrName.getPrefix());
        if (attr == 0) {
            throw new CertificateException("Attribute name not recognized: "
                                           + name);
        }
        // set rawCertInfo to null, so that we are forced to re-encode
        rawCertInfo = null;
        String suffix = attrName.getSuffix();

        switch (attr) {
        case ATTR_VERSION:
            if (suffix == null) {
                version = null;
            } else {
                version.delete(suffix);
            }
            break;
        case (ATTR_SERIAL):
            if (suffix == null) {
                serialNum = null;
            } else {
                serialNum.delete(suffix);
            }
            break;
        case (ATTR_ALGORITHM):
            if (suffix == null) {
                algId = null;
            } else {
                algId.delete(suffix);
            }
            break;
        case (ATTR_ISSUER):
            issuer = null;
            break;
        case (ATTR_VALIDITY):
            if (suffix == null) {
                interval = null;
            } else {
                interval.delete(suffix);
            }
            break;
        case (ATTR_SUBJECT):
            subject = null;
            break;
        case (ATTR_KEY):
            if (suffix == null) {
                pubKey = null;
            } else {
                pubKey.delete(suffix);
            }
            break;
        case (ATTR_ISSUER_ID):
            issuerUniqueId = null;
            break;
        case (ATTR_SUBJECT_ID):
            subjectUniqueId = null;
            break;
        case (ATTR_EXTENSIONS):
            if (suffix == null) {
                extensions = null;
            } else {
                if (extensions != null)
                   extensions.delete(suffix);
            }
            break;
        }
    }