与addSeed(CrawlDatums datums, boolean force) 类似

@param links 种子URL集合
@param type 种子的type标识信息
@param force 是否强制注入
777380
public void addSeed(Iterable<String> links, String type, boolean force) {
        addSeedAndReturn(links, force).type(type);
    }
336522
private void addIndexLink(DeprecatedAPIListBuilder builder,
            int type, Content contentTree) {
        if (builder.hasDocumentation(type)) {
            Content li = HtmlTree.LI(getHyperLink(ANCHORS[type],
                    getResource(HEADING_KEYS[type])));
            contentTree.addContent(li);
        }
    }
567240
protected void getLinkForTypeVariable(Content link, LinkInfo linkInfo, Type type) {
		link.addContent(getTypeAnnotationLinks(linkInfo));
		linkInfo.isTypeBound = true;
		final Doc owner = type.asTypeVariable().owner();
		if ((!linkInfo.excludeTypeParameterLinks) && owner instanceof ClassDoc) {
			linkInfo.classDoc = (ClassDoc) owner;
			final Content label = newContent();
			label.addContent(type.typeName());
			linkInfo.label = label;
			link.addContent(getClassLink(linkInfo));
		} else {
			link.addContent(type.typeName());
		}
		final Type[] bounds = type.asTypeVariable().bounds();
		if (!linkInfo.excludeTypeBounds) {
			linkInfo.excludeTypeBounds = true;
			final SARLFeatureAccess kw = Utils.getKeywords();
			for (int i = 0; i < bounds.length; ++i) {
				link.addContent(i > 0 ? " " + kw.getAmpersandKeyword() + " " //$NON-NLS-1$ //$NON-NLS-2$
						: " " + kw.getExtendsKeyword() + " "); //$NON-NLS-1$ //$NON-NLS-2$
				setBoundsLinkInfo(linkInfo, bounds[i]);
				link.addContent(getLink(linkInfo));
			}
		}
	}
1242542
public void setIncomingLinks(FSArray v) {
    if (Descriptor_Type.featOkTst && ((Descriptor_Type)jcasType).casFeat_incomingLinks == null)
      jcasType.jcas.throwFeatMissing("incomingLinks", "de.julielab.jules.types.wikipedia.Descriptor");
    jcasType.ll_cas.ll_setRefValue(addr, ((Descriptor_Type)jcasType).casFeatCode_incomingLinks, jcasType.ll_cas.ll_getFSRef(v));}
1129764
@SuppressWarnings("static-method")
	protected void getLinkForPrimitive(Content link, LinkInfo linkInfo, Type type) {
		link.addContent(type.typeName());
	}
307862
public Content getTypeParameterLinks(LinkInfoImpl linkInfo) {
        LinkFactoryImpl factory = new LinkFactoryImpl(this);
        return factory.getTypeParameterLinks(linkInfo, false);
    }
350629
public void setWebSeeds(List<WebSeedEntry> seeds) {
        web_seed_entry_vector v = new web_seed_entry_vector();

        for (WebSeedEntry e : seeds) {
            v.push_back(e.swig());
        }

        ti.set_web_seeds(v);
    }
1273896
public void addDataSink(GenericDataSinkBase<?> sink) {
		checkNotNull(sink, "The data sink must not be null.");
		
		if (!this.sinks.contains(sink)) {
			this.sinks.add(sink);
		}
	}
1132923
public synchronized final void append(Link link)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "append");

        Link prev = _dummyTail._getPreviousLink();
        link._link(prev, _dummyTail, _nextPositionToIssue++, this);
        prev._setNextLink(link);
        _dummyTail._setPreviousLink(link);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "append", _debugString());
    }
124549
public void setType (int index, String type)
    {
    if (index >= 0 && index < length) {
        data[index*5+3] = type;
    } else {
        badIndex(index);
    }
    }
688409
@Override
    public void onAdd(Collection<? extends IDataType> dataTypes) throws AtlasException {
        AtlasGraphManagement management = provider.get().getManagementSystem();
               
        for (IDataType dataType : dataTypes) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Creating indexes for type name={}, definition={}", dataType.getName(), dataType.getClass());
            }

            try {
                addIndexForType(management, dataType);
                LOG.info("Index creation for type {} complete", dataType.getName());
            } catch (Throwable throwable) {
                LOG.error("Error creating index for type {}", dataType, throwable);
                //Rollback indexes if any failure
                rollback(management);
                throw new IndexCreationException("Error while creating index for type " + dataType, throwable);
            }
        }

        //Commit indexes
        commit(management);
    }
607641
public void setResourceLinks(java.util.Collection<String> resourceLinks) {
        if (resourceLinks == null) {
            this.resourceLinks = null;
            return;
        }

        this.resourceLinks = new java.util.ArrayList<String>(resourceLinks);
    }
832135
public void associateTypeJndiResource(JNDIResourceModel resource, String type)
    {
        if (type == null || resource == null)
        {
            return;
        }

        if (StringUtils.equals(type, "javax.sql.DataSource") && !(resource instanceof DataSourceModel))
        {
            DataSourceModel ds = GraphService.addTypeToModel(this.getGraphContext(), resource, DataSourceModel.class);
        }
        else if (StringUtils.equals(type, "javax.jms.Queue") && !(resource instanceof JmsDestinationModel))
        {
            JmsDestinationModel jms = GraphService.addTypeToModel(this.getGraphContext(), resource, JmsDestinationModel.class);
            jms.setDestinationType(JmsDestinationType.QUEUE);
        }
        else if (StringUtils.equals(type, "javax.jms.QueueConnectionFactory") && !(resource instanceof JmsConnectionFactoryModel))
        {
            JmsConnectionFactoryModel jms = GraphService.addTypeToModel(this.getGraphContext(), resource, JmsConnectionFactoryModel.class);
            jms.setConnectionFactoryType(JmsDestinationType.QUEUE);
        }
        else if (StringUtils.equals(type, "javax.jms.Topic") && !(resource instanceof JmsDestinationModel))
        {
            JmsDestinationModel jms = GraphService.addTypeToModel(this.getGraphContext(), resource, JmsDestinationModel.class);
            jms.setDestinationType(JmsDestinationType.TOPIC);
        }
        else if (StringUtils.equals(type, "javax.jms.TopicConnectionFactory") && !(resource instanceof JmsConnectionFactoryModel))
        {
            JmsConnectionFactoryModel jms = GraphService.addTypeToModel(this.getGraphContext(), resource, JmsConnectionFactoryModel.class);
            jms.setConnectionFactoryType(JmsDestinationType.TOPIC);
        }
    }
668868
public static void addToRow(PartialRow row, String jpaColumnName, Object value, Type type)
    {
        if (value == null)
        {
            row.setNull(jpaColumnName);
        }
        else
        {
            switch (type)
            {
            case BINARY:
                row.addBinary(jpaColumnName, (byte[]) value);
                break;
            case BOOL:
                row.addBoolean(jpaColumnName, (Boolean) value);
                break;
            case DOUBLE:
                row.addDouble(jpaColumnName, (Double) value);
                break;
            case FLOAT:
                row.addFloat(jpaColumnName, (Float) value);
                break;
            case INT16:
                row.addShort(jpaColumnName, (Short) value);
                break;
            case INT32:
                row.addInt(jpaColumnName, (Integer) value);
                break;
            case INT64:
                row.addLong(jpaColumnName, (Long) value);
                break;
            case INT8:
                row.addByte(jpaColumnName, (Byte) value);
                break;
            case STRING:
                row.addString(jpaColumnName, (String) value);
                break;
            case UNIXTIME_MICROS:
            default:
                logger.error(type + " type is not supported by Kudu");
                throw new KunderaException(type + " type is not supported by Kudu");
            }
        }
    }
120540
public void add(Mtp2 link) {
        // add link at the first empty place
        for (int i = 0; i < links.length; i++) {
            if (links[i] == null) {
                links[i] = link;
                break;
            }
        }
        count++;
        remap();
    }
1059083
public void addPreQualifiedClassLink(LinkInfoImpl.Kind context, TypeElement typeElement, Content contentTree) {
        addPreQualifiedClassLink(context, typeElement, false, contentTree);
    }
340642
@NotNull
  @SuppressWarnings({ "null", "unused" })
  Link processRequest(@NotNull LinkRequest linkRequest) {

    // detect link type - first accepting wins
    LinkType linkType = null;
    List<Class<? extends LinkType>> linkTypes = linkHandlerConfig.getLinkTypes();
    if (linkTypes == null || linkTypes.isEmpty()) {
      throw new RuntimeException("No link types defined.");
    }
    for (Class<? extends LinkType> candidateLinkTypeClass : linkTypes) {
      LinkType candidateLinkType = AdaptTo.notNull(adaptable, candidateLinkTypeClass);
      if (candidateLinkType.accepts(linkRequest)) {
        linkType = candidateLinkType;
        break;
      }
    }
    Link link = new Link(linkType, linkRequest);

    // preprocess link before resolving
    List<Class<? extends LinkProcessor>> linkPreProcessors = linkHandlerConfig.getPreProcessors();
    if (linkPreProcessors != null) {
      for (Class<? extends LinkProcessor> processorClass : linkPreProcessors) {
        LinkProcessor processor = AdaptTo.notNull(adaptable, processorClass);
        link = processor.process(link);
        if (link == null) {
          throw new RuntimeException("LinkPreProcessor '" + processor + "' returned null, page '" + (currentPage != null ? currentPage.getPath() : "-") + "'.");
        }
      }
    }

    // resolve link
    if (linkType != null) {
      link = linkType.resolveLink(link);
      if (link == null) {
        throw new RuntimeException("LinkType '" + linkType + "' returned null, page '" + (currentPage != null ? currentPage.getPath() : "-") + "'.");
      }
    }

    // generate markup (if markup builder is available) - first accepting wins
    List<Class<? extends LinkMarkupBuilder>> linkMarkupBuilders = linkHandlerConfig.getMarkupBuilders();
    if (linkMarkupBuilders != null) {
      for (Class<? extends LinkMarkupBuilder> linkMarkupBuilderClass : linkMarkupBuilders) {
        LinkMarkupBuilder linkMarkupBuilder = AdaptTo.notNull(adaptable, linkMarkupBuilderClass);
        if (linkMarkupBuilder.accepts(link)) {
          link.setAnchor(linkMarkupBuilder.build(link));
          break;
        }
      }
    }

    // postprocess link after resolving
    List<Class<? extends LinkProcessor>> linkPostProcessors = linkHandlerConfig.getPostProcessors();
    if (linkPostProcessors != null) {
      for (Class<? extends LinkProcessor> processorClass : linkPostProcessors) {
        LinkProcessor processor = AdaptTo.notNull(adaptable, processorClass);
        link = processor.process(link);
        if (link == null) {
          throw new RuntimeException("LinkPostProcessor '" + processor + "' returned null, page '" + (currentPage != null ? currentPage.getPath() : "-") + "'.");
        }
      }
    }

    return link;
  }