Adds an EDBObjectEntry to this EDBObject
351110
public void putEDBObjectEntry(String key, Object value, Class<?> type) {
        putEDBObjectEntry(key, value, type.getName());
    }
711903
def add_entry(e)
      @entries.push(e)
      if @md5_to_entries.has_key?(e.md5)
        @md5_to_entries[e.md5].push(e)
      else
        @md5_to_entries[e.md5] = [e]
      end
    end
1313708
public static com.liferay.commerce.model.CommerceSubscriptionEntry addCommerceSubscriptionEntry(
		com.liferay.commerce.model.CommerceSubscriptionEntry commerceSubscriptionEntry) {
		return getService()
				   .addCommerceSubscriptionEntry(commerceSubscriptionEntry);
	}
1146485
protected int addBlock(Collection<Record> candidates,
                         Map.Entry entry) {
    Block block = (Block) entry.getValue();
    String[] ids = block.getIds();
    int ix = 0;
    for (; ix < block.size(); ix++)
      candidates.add(idmap.get(ids[ix]));
    return ix;
  }

  protected NavigableMap makeMap(KeyFunction keyfunc) {
    if (db == null)
      init();

    String name = keyfunc.getClass().getName();
    if (!db.exists(name))
      return db.createTreeMap(name)
        .valueSerializer(new BlockSerializer())
        .make();
    else
      return db.getTreeMap(name);
  }

  // ----- SERIALIZERS

  static class BlockSerializer implements Serializable, Serializer<Block> {
    public void serialize(DataOutput out, Block block) throws IOException {
      int size = block.size();
      out.writeInt(size);
      String[] ids = block.getIds();
      for (int ix = 0; ix < size; ix++)
        out.writeUTF(ids[ix]);
    }

    public Block deserialize(DataInput in, int available) throws IOException {
      int free = in.readInt();
      String[] ids = new String[free];
      for (int ix = 0; ix < free; ix++)
        ids[ix] = in.readUTF();
      return new Block(free, ids);
    }

    public int fixedSize() {
      return -1;
    }
  }

  static class RecordSerializer implements Serializable, Serializer<CompactRecord> {
    public void serialize(DataOutput out, CompactRecord value) throws IOException {
      int free = value.getFree();
      out.writeInt(free);
      String[] s = value.getArray();
      for (int ix = 0; ix < free; ix++)
        out.writeUTF(s[ix]);
    }

    public CompactRecord deserialize(DataInput in, int available) throws IOException {
      int free = in.readInt();
      String[] s = new String[free];
      for (int ix = 0; ix < free; ix++)
        s[ix] = in.readUTF();
      return new CompactRecord(free, s);
    }

    public int fixedSize() {
      return -1;
    }
  }
}
1009841
private static void addToOpenEngSBModelEntries(CtClass clazz) throws NotFoundException,
        CannotCompileException, ClassNotFoundException {
        CtClass[] params = generateClassField();
        CtMethod m = new CtMethod(cp.get(List.class.getName()), "toOpenEngSBModelEntries", params, clazz);
        StringBuilder builder = new StringBuilder();
        builder.append(createTrace("Add elements of the model tail"))
            .append("List elements = new ArrayList();\n")
            .append(String.format("elements.addAll(%s.values());\n", TAIL_FIELD))
            .append("elements.addAll(toOpenEngSBModelValues());\n")
            .append("return elements;");
        m.setBody(createMethodBody(builder.toString()));
        clazz.addMethod(m);
    }
966910
public static JPAEntry convertEDBObjectEntryToJPAEntry(EDBObjectEntry entry, JPAObject owner) {
        for (EDBConverterStep step : steps) {
            if (step.doesStepFit(entry.getType())) {
                LOGGER.debug("EDBConverterStep {} fit for type {}", step.getClass().getName(), entry.getType());
                return step.convertToJPAEntry(entry, owner);
            }
        }
        LOGGER.error("No EDBConverterStep fit for EDBObjectEntry {}", entry);
        return null;
    }
1206323
public final void addEntries(Entry<?>... entries) {
        if (entries != null) {
            for (Entry<?> entry : entries) {
                entry.setCalendar(this);
            }
        }
    }
9129
@Override
  public void addEntry(Archivable arch) throws IOException {
    final String fn = arch.getFileName();
    TarArchiveEntry entry = new TarArchiveEntry(fn);
    byte[] cbytes = arch.getBytes();
    entry.setSize(cbytes.length);
    this.tos.putArchiveEntry(entry);
    try (ByteArrayInputStream bis = new ByteArrayInputStream(cbytes)) {
      IOUtils.copy(bis, tos);
      tos.closeArchiveEntry();
    }
  }
629919
def __AddEntryType(self, entry_type_name, entry_schema, parent_name):
        """"""
        entry_schema.pop('description', None)
        description = 'Single entry in a %s.' % parent_name
        schema = {
            'id': entry_type_name,
            'type': 'object',
            'description': description,
            'properties': {
                'entry': {
                    'type': 'array',
                    'items': entry_schema,
                },
            },
        }
        self.AddDescriptorFromSchema(entry_type_name, schema)
        return entry_type_name
1342271
public void add(FutureReadResultEntry entry) {
        synchronized (this.reads) {
            Exceptions.checkNotClosed(this.closed, this);
            this.reads.add(entry);
        }
    }
726540
private void appendEntry(Map.Entry<String, EDBObjectEntry> entry, StringBuilder builder) {
        if (builder.length() > 2) {
            builder.append(",");
        }
        builder.append(" \"").append(entry.getKey()).append("\"");
        builder.append(" : ").append(entry.getValue());
    }
199628
@Override
    public void add(QueryableEntry entry) {
        if (++resultSize > resultLimit) {
            throw new QueryResultSizeExceededException();
        }

        rows.add(orderAndLimitExpected ? entry : convertEntryToRow(entry));
    }
691064
public void addObject(DigitalObject obj) throws ResourceIndexException {
        m_ri.addObject(new SimpleDOReader(null, null, null, null, null, obj));
    }
360904
private void addParameterDeletesObligationDatabaseEntry(XMethod xmethod, Obligation obligation,
            ObligationPolicyDatabaseEntryType entryType) {
        ObligationPolicyDatabaseEntry entry = database.addParameterDeletesObligationDatabaseEntry(xmethod, obligation, entryType);
        if (DEBUG_ANNOTATIONS) {
            System.out.println("Added entry: " + entry);
        }
    }
1029466
public void add(Counter<? extends T> counter) {
        for (Map.Entry<? extends T,Integer> e : counter)
            count(e.getKey(), e.getValue());
    }
    
    /**
     * Counts the object, increasing its total count by 1.
     */
    public int count(T obj) {
        int objIndex = (allowNewIndices) 
            ? objectIndices.index(obj)
            : objectIndices.find(obj);
        if (objIndex < 0)
            return 0;
        int curCount = indexToCount.get(objIndex);
        indexToCount.put(objIndex, curCount + 1);
        sum++;
        return curCount + 1;
    }
503089
public void addEntry(String key, String type, String widget, String params, String optional) {

        m_entries.add(new CmsWorkplaceUserInfoEntry(key, type, widget, params, optional));
    }
1246147
public static JPAObject convertEDBObjectToJPAObject(EDBObject object) {
        JPAObject result = new JPAObject();
        result.setTimestamp(object.getTimestamp());
        result.setOID(object.getOID());
        result.setDeleted(object.isDeleted());
        List<JPAEntry> entries = new ArrayList<JPAEntry>();
        for (EDBObjectEntry entry : object.values()) {
            entries.add(convertEDBObjectEntryToJPAEntry(entry, result));
        }
        result.setEntries(entries);
        return result;
    }