Delete a report definition

 @param[ReportDefinition, Number]
322894
def report_definition_delete(repdef_or_id)
      if repdef_or_id.class == ReportDefinition
        report_definition = repdef_or_id
      else
        report_definition = ReportDefinition.new(self)
        report_definition.instance_eval { @id = repdef_or_id }
      end

      op           = ReportDefinitionOperation.remove(report_definition)
      soap_message = service.report_definition.mutate(credentials, op.to_xml)
      add_counters(soap_message.counters)

      unless @report_definitions
        @report_definition.delete_if { |repdef| repdef == report_definition.id }
      end
      report_definition.instance_eval { @id = -1 } # repdef status invalid/deleted
      self
    end
245320
public void delete ()
    {
        IntBuffer idbuf = BufferUtils.createIntBuffer(1);
        idbuf.put(_id).rewind();
        AL10.alDeleteBuffers(idbuf);
        _id = 0;
    }
545389
public void deleteScalarValueColumn(TableDefinition tableDef, String objID, String fieldName) {
        deleteColumn(SpiderService.objectsStoreName(tableDef), objID, fieldName);
    }
382357
@Deprecated
    public void deleteIssue(Integer id) throws RedmineException {
        transport.deleteObject(Issue.class, Integer.toString(id));
    }
945419
public void removeTableDef(TableDefinition tableDef) {
        assert tableDef != null;
        assert tableDef.getAppDef() == this;
        
        m_tableMap.remove(tableDef.getTableName());
    }
42839
protected void removeLocalSpaceDefinition(SpaceID id, boolean isLocalDestruction) {
		final Space space;
		synchronized (getSpaceRepositoryMutex()) {
			space = this.spaces.remove(id);
			if (space != null) {
				this.spacesBySpec.remove(id.getSpaceSpecification(), id);
			}
		}
		if (space != null) {
			fireSpaceRemoved(space, isLocalDestruction);
		}
	}
720669
public void delete()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "delete");
        //Tell the target of the alias to remove the backwards reference to it
        _targetDestinationHandler.removeTargettingAlias(this);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "delete");
    }
614353
@Indexable(type = IndexableType.DELETE)
	@Override
	public CPDefinitionInventory deleteCPDefinitionInventory(
		CPDefinitionInventory cpDefinitionInventory) {
		return cpDefinitionInventoryPersistence.remove(cpDefinitionInventory);
	}
1234720
@Indexable(type = IndexableType.DELETE)
	@Override
	public CPDefinitionLink deleteCPDefinitionLink(
		CPDefinitionLink cpDefinitionLink) {
		return cpDefinitionLinkPersistence.remove(cpDefinitionLink);
	}
304139
def delete_object(no, generation = 0)
            case no
            when Reference
                target = no
            when ::Integer
                target = Reference.new(no, generation)
            else
                raise TypeError, "Invalid parameter type : #{no.class}"
            end

            @revisions.each do |rev|
                rev.body.delete(target)
            end
        end
1150430
public void deleteRelation(Integer id) throws RedmineException {
		transport.deleteObject(IssueRelation.class, Integer.toString(id));
    }
746465
def delete(name)
      name = normalize_header name.to_s
      @pile.delete_if { |k, _| k == name }
    end
539687
@Override
	public void removeByCPDefinitionId(long CPDefinitionId) {
		for (CPDefinitionSpecificationOptionValue cpDefinitionSpecificationOptionValue : findByCPDefinitionId(
				CPDefinitionId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionSpecificationOptionValue);
		}
	}
1198011
def delete_report(report):
    
    for path in glob.glob(os.path.join(_get_reports_path(), report)):
        shutil.rmtree(path)
837240
def delete(observer)
      old_size = @stack.size
      @stack.delete_if do |o|
        o[:observer] == observer
      end
      old_size == @stack.size ? nil : observer
    end
1302371
public void delete(int count) throws BufferSizeException {
        if ((count < 0) || (count > capacity())) {
            throw new IllegalArgumentException("Can only delete between 0 and " + capacity() + " bytes from buffer, you passed in=" + count);
        }
        if (count > size()) {
            throw new BufferSizeException("Buffer size (" + size() + ") not large enough to delete (" + count + ") bytes");
        }
        this.currentReadPosition = (this.currentReadPosition + count) % this.buffer.length;
        this.currentBufferSize -= count;
    }
227827
public function setDefinition($reportDefinition)
    {
        if ($reportDefinition instanceof ReportDefinitionBuilder) {
            $reportDefinition = $reportDefinition->build();
        }

        $this->definition = $reportDefinition;

        return $this;
    }