Adds entries to the audit log.

@param data The json data of the audit log.
422887
public void addEntries(JsonNode data) {
        for (JsonNode webhookJson : data.get("webhooks")) {
            boolean alreadyAdded = involvedWebhooks.stream()
                    .anyMatch(webhook -> webhook.getId() == webhookJson.get("id").asLong());
            if (!alreadyAdded) {
                involvedWebhooks.add(new WebhookImpl(api, webhookJson));
            }
        }
        for (JsonNode userJson : data.get("users")) {
            boolean alreadyAdded = involvedUsers.stream()
                    .anyMatch(user -> user.getId() == userJson.get("id").asLong());
            if (!alreadyAdded) {
                involvedUsers.add(((DiscordApiImpl) api).getOrCreateUser(userJson));
            }
        }
        for (JsonNode entry : data.get("audit_log_entries")) {
            entries.add(new AuditLogEntryImpl(this, entry));
        }
    }
290386
public void append(byte[] data) {
        if (data.length >= (this.datas.length - size)) {
            // 扩容
            byte[] newData = new byte[this.datas.length + data.length + this.datas.length / 2];
            System.arraycopy(this.datas, 0, newData, 0, size);
            this.datas = newData;
        }
        System.arraycopy(data, 0, this.datas, size, data.length);
        this.size += data.length;
        modCount++;
    }
830205
public final void setData(@Nullable Data<?> data) {
        setDatas(data != null ? singleton(data) : Collections.<Data<?>>emptyList());
    }
1158024
public void add(DATA data) {
		if(root == null) {
			root = new RootLeafNode(data);
			try {
				root.addData(data, 0);
			} catch (SplitNodeReplacement e) {
				throw new RuntimeException("Should never happen!");
			}
		} else {
			double distance = distanceFunction.calculate(data, root.data);
			try {
				root.addData(data, distance);
			} catch(SplitNodeReplacement e) {
				Node newRoot = new RootNode(data);
				root = newRoot;
				for(int i = 0; i < e.newNodes.length; i++) {
					@SuppressWarnings("unchecked")
					Node newNode = (Node) e.newNodes[i];
					distance = distanceFunction.calculate(root.data, newNode.data);
					root.addChild(newNode, distance);
				}
			}
		}
	}
222661
static void addEntry(ZipEntry zipEntry, InputStream in, ZipOutputStream out) throws IOException {
    out.putNextEntry(zipEntry);
    if (in != null) {
      IOUtils.copy(in, out);
    }
    out.closeEntry();
  }
1292715
@Override
    public void add(final byte[] key, final byte[] data) throws IOException {
        this.datas.put(new BytesKey(key), data);
    }
160407
public void append(SimpleTypeInformation<?> meta, Object data) {
    this.meta.add(meta);
    this.contents.add(data);
  }
1214328
private void add(Iterable<?> data) {

    for (Object el : data) {
      try {
        add(SoyData.createFromExistingData(el));

      } catch (SoyDataException sde) {
        sde.prependIndexToDataPath(list.size());
        throw sde;
      }
    }
  }
144806
public void setEntries(java.util.Collection<DatasetEntry> entries) {
        if (entries == null) {
            this.entries = null;
            return;
        }

        this.entries = new java.util.ArrayList<DatasetEntry>(entries);
    }
376537
public void addData(int index, byte[] data) throws InternalLogException
  {
    if (tc.isEntryEnabled()) Tr.entry(tc, "addData",new java.lang.Object[] {new Integer(index), RLSUtils.toHexString(data,RLSUtils.MAX_DISPLAY_BYTES), this});

    // If the parent recovery log instance has experienced a serious internal error then prevent
    // this operation from executing.
    if (_recLog.failed())
    {
      if (tc.isEntryEnabled()) Tr.exit(tc, "addData",this);
      throw new InternalLogException(null);
    }

    // we use an index value of 0 to indicate that it is a singledata RUsection
    // so adjust now ... if (!_singleData) or if(index != 0)
    if (index > 0) index--;         

    // list items may be added in any order, so it may be necessary to (temporarily) pad the list
    final int currentSize = _writtenData.size();
    if (index == currentSize)
        _writtenData.add(/*index,*/ data);
    else if (index < currentSize)
    {
        if (tc.isDebugEnabled()) Tr.debug(tc, "NMTEST: Replacing item (expect trace 'null') at index: " + index, _writtenData.get(index));
        _writtenData.set(index, data);
    }
    else // index > currentSize
    {
        if (tc.isDebugEnabled()) Tr.debug(tc, "NMTEST: Adding null elements: " + (index-currentSize));
        while (index-- > currentSize)
            _writtenData.add(null);

        _writtenData.add(data);        
    }

    // set lastdata.  This method is called during recovery and we shouldn't get asked for
    // any data until all log records are read.  So set lastdata to be the item at the current size
    // of the array.  Items may be added in random order, so lastitem will be correct when
    // all items have been added
    _lastDataItem = (byte[]) _writtenData.get(_writtenData.size() -1);

    if (tc.isEntryEnabled()) Tr.exit(tc, "addData");
  }
1052205
public void addRow(final String[] data) {
		if (anyStringContainsNewLine(data)) {
			final String[][] theMatrix = Util.createMatrix(data);
			for (int i = 0; i < theMatrix.length; i++) {
				addRow(theMatrix[i]);
			}
		} else {
			final Row myRow = new Row(this, data);
			rows.add(myRow);
		}

	}
1107917
@Override
    public AuditOutputStream<AuditEvent> write(AuditEvent event) {
         outputStream.write(handler.enhanceFromMetadata(event));
         return outputStream;
    }
645794
public void addData(final TimeData DATA) {
        sum += DATA.getValue();
        window.add(DATA);
        if (window.size() > period) {
            sum -= window.remove().getValue();
        }
    }
1240657
public void setData (Object data)
    {
        _data.clear();
        _data.add(data);
        _model.fireTableDataChanged();
    }
455641
public void addRow(String[] data) {

        if (data.length != iColCount) {
            return;
        }

        String[] row = new String[iColCount];

        for (int i = 0; i < iColCount; i++) {
            row[i] = data[i];

            if (row[i] == null) {
                row[i] = "(null)";
            }
        }

        vData.addElement(row);

        iRowCount++;
    }
717674
public void append(final byte[] data, final int start, final int len) {
		final int oldLength = this.bytes.length;
		setCapacity(this.bytes.length + len, true);
		System.arraycopy(data, start, this.bytes, oldLength, len);
	}
1342640
public synchronized void put(byte[] data) {
        references.remove(data);

        if (mainFilter.add(data)) {
            for (Integer i : SIZES) {
                if (data.length == i) {
                    fastBuffers.get(i).add(data);
                    return;
                }
            }
            if (data.length <= MAX_SIZE) {
                return;
            }
            byteBuffer.add(data);
        }
    }