Adds queue entries for this concept based on the new axioms added in an incremental classification.

@param conceptEntries
@param roleEntries
@param featureEntries
189535
public void primeQueuesIncremental(
            MonotonicCollection<IConjunctionQueueEntry> conceptEntries,
            MonotonicCollection<IRoleQueueEntry> roleEntries,
            MonotonicCollection<IFeatureQueueEntry> featureEntries) {
        if (conceptEntries != null)
            addToConceptQueue(conceptEntries);
        if (roleEntries != null)
            roleQueue.addAll(roleEntries);
        if (featureEntries != null)
            featureQueue.addAll(featureEntries);
    }
1021741
public void setDomainEntries(java.util.Collection<DomainEntry> domainEntries) {
        if (domainEntries == null) {
            this.domainEntries = null;
            return;
        }

        this.domainEntries = new java.util.ArrayList<DomainEntry>(domainEntries);
    }
321859
public void addFeature(int bioStart, int bioEnd, FeatureInterface<AbstractSequence<C>, C> feature) {
		SequenceLocation<AbstractSequence<C>, C> sequenceLocation =
				new SequenceLocation<AbstractSequence<C>, C>(bioStart, bioEnd, this);
		feature.setLocation(sequenceLocation);
		addFeature(feature);
	}
855314
protected synchronized void applyEntries(boolean blocking) throws IOException {
    if (blocking) { /* Blocking Mode */
      synchronized(_entryApply) {
        List<Entry<V>> entryList = new ArrayList<Entry<V>>();
        while(_entryPool.getServiceQueueSize() > 0) {
          Entry<V> entry = _entryPool.pollFromService();
          if(entry != null) entryList.add(entry);
        }
        
        applyEntries(entryList);
      }
    } else {        /* Non-Blocking Mode */
      synchronized(_entryApply) {
        for(int i = 0; i < _maxEntries; i++) {
          Entry<V> entry = _entryPool.pollFromService();
          if(entry != null) _entryApply.add(entry);
        }
      }
      
      // Start a separate thread to update the underlying array file 
      new Thread(_entryApply).start();
    }
  }
827795
public void setBlockers(java.util.Collection<BlockerDeclaration> blockers) {
        if (blockers == null) {
            this.blockers = null;
            return;
        }

        this.blockers = new java.util.ArrayList<BlockerDeclaration>(blockers);
    }
144806
public void setEntries(java.util.Collection<DatasetEntry> entries) {
        if (entries == null) {
            this.entries = null;
            return;
        }

        this.entries = new java.util.ArrayList<DatasetEntry>(entries);
    }
542767
public void setMapEntries(java.util.Collection<ParameterMapEntry> mapEntries) {
        if (mapEntries == null) {
            this.mapEntries = null;
            return;
        }

        this.mapEntries = new java.util.ArrayList<ParameterMapEntry>(mapEntries);
    }
354076
@Override
    public synchronized void add(DiscoveryEntry discoveryEntry) {
        if (discoveryEntry.getDomain() == null || discoveryEntry.getInterfaceName() == null
                || discoveryEntry.getParticipantId() == null) {
            String message = "discoveryEntry being registered is not complete: " + discoveryEntry;
            logger.error(message);
            throw new JoynrCommunicationException(message);
        }

        synchronized (storeLock) {
            String discoveryEntryId = domainInterfaceParticipantIdKey(discoveryEntry.getDomain(),
                                                                      discoveryEntry.getInterfaceName(),
                                                                      discoveryEntry.getParticipantId());
            DiscoveryEntry entry = capabilityKeyToCapabilityMapping.get(discoveryEntryId);
            // check if a DiscoveryEntry with the same Id already exists
            if (entry != null) {
                remove(discoveryEntry.getParticipantId());
            }

            // update participantId to capability mapping
            capabilityKeyToCapabilityMapping.put(discoveryEntryId, discoveryEntry);

            // update time mapping
            registeredCapabilitiesTime.put(discoveryEntryId, System.currentTimeMillis());

            // update interfaceDomain to capability mapping
            String domainInterfaceId = domainInterfaceKey(discoveryEntry.getDomain(),
                                                          discoveryEntry.getInterfaceName());

            // if domainInterfaceId not in the mapping, map it to an empty map,
            // otherwise use the mapping that is  already there
            List<String> newMapping = new ArrayList<String>();
            List<String> mapping = interfaceAddressToCapabilityMapping.putIfAbsent(domainInterfaceId, newMapping);
            if (mapping == null) {
                mapping = newMapping;
            }

            mapping.add(discoveryEntryId);

            // update participantId to capability mapping
            String participantId = discoveryEntry.getParticipantId();

            participantIdToCapabilityMapping.put(participantId, discoveryEntryId);
        }
    }
380681
public void addFeatures(Map<VectorLayer, List<Feature>> featureMap, Criterion criterion) {
		if (showDetailsOnSingleResult && featureMap.size() == 1) {
			// sorting is never needed if only 1 entry
			List<Feature> features = featureMap.values().iterator().next();
			if (features.size() == 1) {
				showFeatureDetailWindow(map, features.get(0));
			}
		}

		//Add feature tabs in map order
		for (VectorLayer layer : map.getMapModel().getVectorLayers()) {
			if (featureMap.containsKey(layer)) {
				addFeatures(layer, featureMap.get(layer), criterion);
			}
		}
		tabset.selectTab(0);
	}
1277644
public void setFeaturesListLabels(Map<String, String> featuresListLabels) {
		this.featuresListLabels = featuresListLabels;
		controller.setFeaturesListLabels(featuresListLabels);
	}
308127
void merge(RepositoryEntry entry)
   {
      merge((RepositoryInfo)entry);
      List<WorkspaceEntry> workspaceEntries = entry.workspaces;
      if (workspaceEntries == null || workspaceEntries.isEmpty())
      {
         return;
      }
      if (workspaces == null || workspaces.isEmpty())
      {
         this.workspaces = workspaceEntries;
         return;
      }
      Map<String, WorkspaceEntry> mWorkspaceEntries = new LinkedHashMap<String, WorkspaceEntry>();
      for (WorkspaceEntry wkEntry : workspaceEntries)
      {
         mWorkspaceEntries.put(wkEntry.getName(), wkEntry);
      }
      for (WorkspaceEntry wkEntry : workspaces)
      {
         mWorkspaceEntries.put(wkEntry.getName(), wkEntry);
      }
      this.workspaces = new ArrayList<WorkspaceEntry>(mWorkspaceEntries.values());
   }
1046837
private static void addDescriptions(Entry entry, String... descriptions) {
        try {
            entry.add(SchemaConstants.OBJECT_CLASS_ATTRIBUTE, SchemaConstants.DESCRIPTIVE_OBJECT_OC);
            if (descriptions == null) {
                // case 1
                entry.add(SchemaConstants.EMPTY_FLAG_ATTRIBUTE, String.valueOf(false));
            } else if (descriptions.length == 1 && descriptions[0].isEmpty()) {
                // case 2
                entry.add(SchemaConstants.EMPTY_FLAG_ATTRIBUTE, String.valueOf(true));
            } else {
                // case 3
                entry.add(SchemaConstants.STRING_ATTRIBUTE,
                        StringUtils.join(descriptions, ServerConfig.multipleValueSeparator));
            }
        } catch (LdapException e) {
            throw new LdapRuntimeException(e);
        }
    }
951215
public void setPolicyRoles(java.util.Collection<PolicyRole> policyRoles) {
        if (policyRoles == null) {
            this.policyRoles = null;
            return;
        }

        this.policyRoles = new com.amazonaws.internal.SdkInternalList<PolicyRole>(policyRoles);
    }
298977
private void processOntologyTracking() {
        boolean done;

        do {
            done = true;

            // Process concept queue
            if (!conceptQueue.isEmpty()) {
                do {
                    done = false;
                    final IConjunctionQueueEntry entry = conceptQueue.remove();
                    final int b = entry.getB();

                    if (!s.contains(b)) {
                        final int bi = entry.getBi();
                        if (s.contains(bi)) {
                            s.add(b);
                            changed = true;
                            processNewSubsumptionTracking(b);
                        }
                    }
                } while (!conceptQueue.isEmpty());
            }

            // Process feature queue
            if (!featureQueue.isEmpty()) {
                do {
                    done = false;
                    final IFeatureQueueEntry entry = featureQueue.remove();

                    Datatype d = entry.getD();

                    // Handle functional features
                    checkFunctionalFeatures(d);

                    // Get right hand sides from NF8 expressions that
                    // match d on their left hand side
                    MonotonicCollection<NF8> entries =
                            ontologyNF8.get(d.getFeature());

                    if (entries == null)
                        continue;

                    // Evaluate to determine the ones that match
                    MonotonicCollection<IConjunctionQueueEntry> res =
                            new MonotonicCollection<IConjunctionQueueEntry>(2);
                    for (final NF8 e : entries) {
                        Datatype d2 = e.lhsD;

                        // If they match add a conjunction queue entry
                        // to queueA
                        if (datatypeMatches(d, d2)) {
                            res.add(new IConjunctionQueueEntry() {
                                /**
                                 * Serialisation version.
                                 */
                                private static final long serialVersionUID = 1L;

                                @Override
                                public int getBi() {
                                    return CoreFactory.TOP_CONCEPT;
                                }

                                @Override
                                public int getB() {
                                    return e.rhsB;
                                }
                            });
                        }
                    }

                    addToConceptQueue(res);
                } while (!featureQueue.isEmpty());
            }

            // Process role queue
            if (!roleQueue.isEmpty()) {
                done = false;
                final IRoleQueueEntry entry = roleQueue.remove();

                if (!succ.lookupConcept(entry.getR()).contains(entry.getB())) {
                    processNewEdgeTracking(entry.getR(), entry.getB());
                }
            }

            if (!externalQueue.isEmpty()) {
                done = false;
                final IRoleQueueEntry entry = externalQueue.remove();
                processNewEdgeTracking(entry.getR(), entry.getB());
            }

        } while (!done);
    }
244448
public void addFeature(com.ibm.websphere.servlet.container.WebContainer.Feature feature) {
        this.features.add(feature);
    }
1351496
void add(Entry<String, Point2d[]> entry) {
        if (entry != null) templateMap.put(entry.getKey(), entry.getValue());
    }
100014
private void _addFeatureOnce(Object name, Feature feature) {
        String _name = String.valueOf(name);
        if (!this.feature().containsKey(_name)) {
            this.feature().put(_name, feature);
        }
    }