Create a new {@link AddonDependencyEntry} with the given attributes.
197339
public static AddonDependencyEntry create(String name, boolean exported, boolean optional)
   {
      return create(name, new EmptyVersionRange(), exported, optional);
   }
635560
@Override
    public final Object createEntry(Object key) throws Exception {
        final A data = threadData.get();
        return this.createEntry(key, data);
    }
727511
@Override
	public synchronized boolean addEntry(Principal caller, Principal principal, String permission)
	{
		return addEntry(caller, new SecurityAccessControl(principal, permission));
	}
263591
public void addEntry(String placeholder, String... params) {
        ConfigEntry entry = entries.get(placeholder);
        String line = entry.template;

        for (int i = 0; i < params.length; i++) {
            line = line.replace("{" + i + "}", StringUtils.defaultString(params[i]));
        }

        entry.buffer.add(line);
    }
474531
public void createSubEntry(final CmsClientSitemapEntry newEntry, CmsUUID parentId, CmsUUID structureId) {

        if (structureId == null) {
            structureId = m_data.getDefaultNewElementInfo().getCopyResourceId();
        }
        create(newEntry, parentId, m_data.getDefaultNewElementInfo().getId(), structureId, null, false);
    }
363906
public static <K, V> Entry<K, V> entry(final K key, final V value) {
        return new SimpleImmutableEntry<K, V>(key, value);
    }
932589
@Override
    public Promise<DeferredVoid> add(final DiscoveryEntry discoveryEntry) {
        boolean awaitGlobalRegistration = false;
        return add(discoveryEntry, awaitGlobalRegistration);
    }
377790
public HousingComplexUtilityAccount instantiateForInsert() {
		HousingComplexUtilityAccount entity = new HousingComplexUtilityAccount();
		entity.setIsDeleted(Boolean.FALSE);
		return entity;
    }
810325
public KeePassFileBuilder addTopEntries(Entry... entries) {
        for (Entry entry : entries) {
            topGroupBuilder.addEntry(entry);
        }

        return this;
    }
1248933
private static AuditEntryBean newEntry(String orgId, AuditEntityType type, ISecurityContext securityContext) {
        // Wait for 1 ms to guarantee that two audit entries are never created at the same moment in time (which would
        // result in non-deterministic sorting by the storage layer)
        try { Thread.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); }

        AuditEntryBean entry = new AuditEntryBean();
        entry.setOrganizationId(orgId);
        entry.setEntityType(type);
        entry.setCreatedOn(new Date());
        entry.setWho(securityContext.getCurrentUser());
        return entry;
    }
1180388
def add(self, entry, local_file):
        """"""
        row = self.rowClass()

        for key, val in entry.items():
            if key in self.columns:
                setattr(row, key, val)

        row.local_filename = os.path.join('.', os.path.relpath(local_file))

        self.rows.append(row)
227285
private static void addEntry(ZipEntrySource entry, ZipOutputStream out) throws IOException {
    out.putNextEntry(entry.getEntry());
    InputStream in = entry.getInputStream();
    if (in != null) {
      try {
        IOUtils.copy(in, out);
      }
      finally {
        IOUtils.closeQuietly(in);
      }
    }
    out.closeEntry();
  }
1273528
private void createCellsAndAddToRow(Object entity, MetamodelImpl metaModel, Set<Attribute> attributes,
            HBaseRow hbaseRow, EntityMetadata m, int count, String prefix)
    {
        AbstractAttribute idCol = (AbstractAttribute) m.getIdAttribute();
        for (Attribute attribute : attributes)
        {
            AbstractAttribute absAttrib = (AbstractAttribute) attribute;
            Class clazz = absAttrib.getBindableJavaType();
            if (metaModel.isEmbeddable(clazz))
            {
                Set<Attribute> attribEmbeddables = metaModel.embeddable(absAttrib.getBindableJavaType())
                        .getAttributes();
                Object embeddedField = PropertyAccessorHelper.getObject(entity, (Field) attribute.getJavaMember());
                if (attribute.isCollection() && embeddedField != null)
                {
                    int newCount = count + 1;
                    String newPrefix = prefix != "" ? prefix + absAttrib.getJPAColumnName() + HBaseUtils.DELIM
                            : absAttrib.getJPAColumnName() + HBaseUtils.DELIM;
                    List listOfEmbeddables = (List) embeddedField;
                    addColumnForCollectionSize(hbaseRow, listOfEmbeddables.size(), newPrefix, m.getTableName());
                    for (Object obj : listOfEmbeddables)
                    {
                        createCellsAndAddToRow(obj, metaModel, attribEmbeddables, hbaseRow, m, newCount++, newPrefix);
                    }
                }
                else if (embeddedField != null)
                {
                    String newPrefix = prefix != "" ? prefix + absAttrib.getJPAColumnName() + HBaseUtils.DOT
                            : absAttrib.getJPAColumnName() + HBaseUtils.DOT;
                    createCellsAndAddToRow(embeddedField, metaModel, attribEmbeddables, hbaseRow, m, count, newPrefix);
                }
            }
            else if (!attribute.isCollection() && !attribute.isAssociation())
            {
                String columnFamily = absAttrib.getTableName() != null ? absAttrib.getTableName() : m.getTableName();
                String columnName = absAttrib.getJPAColumnName();
                columnName = count != -1 ? prefix + columnName + HBaseUtils.DELIM + count : prefix + columnName;
                Object value = PropertyAccessorHelper.getObject(entity, (Field) attribute.getJavaMember());
                HBaseCell hbaseCell = new HBaseCell(columnFamily, columnName, value);
                if (!idCol.getName().equals(attribute.getName()) && value != null)
                {
                    hbaseRow.addCell(hbaseCell);
                }
            }
        }
    }
1289562
@Override
	public boolean add(FeatureI feature) {
		if (mLocation == null) {
			mLocation = feature.location().plus();
		} else if (null != feature.location()) {
			mLocation = mLocation.union(feature.location().plus());
		}
		for (Entry<String, String> entry : feature.getAttributes().entrySet()){
			if (featindex.containsKey(entry.getKey())){
				Map<String,List<FeatureI>> feat = featindex.get(entry.getKey());
				if (feat==null){
					feat= new HashMap<String,List<FeatureI>>();
				}
				List<FeatureI> features = feat.get(entry.getValue());
				if (features==null){
					features = new ArrayList<FeatureI>();
				}
				features.add(feature);
				feat.put(entry.getValue(), features);
				featindex.put(entry.getKey(), feat);
				//featindex.put(key, value)
			}
		}

		return super.add(feature);
	}
820913
private <I> void addConsideringOrder(Map<String, I> map, I newEntry) {
    for(Map.Entry<String, I> entry : map.entrySet()) {
      if(entry.getValue() instanceof MustBeAfter<?>) {
        final Class<? extends ClassLoaderPreMortemCleanUp>[] existingMustBeAfter = 
            ((MustBeAfter<ClassLoaderPreMortemCleanUp>)entry.getValue()).mustBeBeforeMe();
        for(Class<? extends ClassLoaderPreMortemCleanUp> clazz : existingMustBeAfter) {
          if(clazz.isAssignableFrom(newEntry.getClass())) { // Entry needs to be after new entry
            // TODO Resolve order automatically #51
            throw new IllegalStateException(clazz.getName() + " must be added after " + newEntry.getClass());
          }
        }
      }
    }
    
    map.put(newEntry.getClass().getName(), newEntry);
  }
389178
public static <K,V> Entry<K,V> kv(final K key, final V val) {
		return new SerializableEntry<>(key, val);
	}
448380
public static AddonDependencyEntry create(String name, boolean exported)
   {
      return create(name, new EmptyVersionRange(), exported, false);
   }