Creates a new node and adds it to the DagBuilder.

@param name name of the node
@param nodeProcessor node processor associated with this node
@return a new node
@throws DagException if the name is not unique in the DAG.
174787
public Node createNode(final String name, final NodeProcessor nodeProcessor) {
    checkIsBuilt();

    if (this.nameToNodeMap.get(name) != null) {
      throw new DagException(String.format("Node names in %s need to be unique. The name "
          + "(%s) already exists.", this, name));
    }
    final Node node = new Node(name, nodeProcessor, this.dag);
    this.nameToNodeMap.put(name, node);

    return node;
  }
145463
public ISarlAnnotationTypeBuilder addSarlAnnotationType(String name) {
		ISarlAnnotationTypeBuilder builder = this.iSarlAnnotationTypeBuilderProvider.get();
		builder.eInit(getSarlAgent(), name, getTypeResolutionContext());
		return builder;
	}
1325532
public static final void nodeName(String name)
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "nodeName", name);

        _nodeName = name;

        if (tc.isEntryEnabled())
            Tr.exit(tc, "nodeName");
    }
702885
def on_name(node, compiled_grammar)
      if compiled_grammar.name
        compiled_grammar.add_warning(
          "Overwriting existing parser name #{compiled_grammar.name.inspect}",
          node.source_line
        )
      end

      parts = node.children.map { |child| process(child, compiled_grammar) }

      compiled_grammar.name = parts.join('::')
    end
649941
public static Runner newInstance(String name)
    {
        Runner runner = new Runner();
        runner.setName(name);
        
        return runner;
    }
980948
static Node newVarNode(String name, Node value) {
    Node lhs = IR.name(name);
    if (value != null) {
      lhs.srcref(value);
    }
    return newVarNode(lhs, value);
  }
529409
public Processor newProcessor(final String transtype) {
        if (ditaDir == null) {
            throw new IllegalStateException();
        }
        if (!Configuration.transtypes.contains(transtype)) {
            throw new IllegalArgumentException("Transtype " + transtype + " not supported");
        }
        return new Processor(ditaDir, transtype, Collections.unmodifiableMap(args));
    }
1316328
def node(name, options = {}, &block)
        return unless resolve_condition(options)

        result = block.call(@_object)
        if name.present?
          @_result[create_key(name)] = result
        elsif result.is_a?(Hash) # merge hash into root hash
          @_result.merge!(result)
        end
      end
688147
public Branch createBranch(String name) throws IOException
    {
        Label label = labels.get(name);
        if (label == null)
        {
            label = new Label(name);
            labels.put(name, label);
        }
        return label.createBranch(position());
    }
202098
def task(options, &block)
      name, params = *options

      raise "Couldn't create task without a name" if name.nil?
      raise "Couldn't create task without a block" unless block_given?

      task = Task.new(name, params)
      task.instance_eval(&block)

      @dag.add_vertex(name: name, task: task)
    end
1238471
function Builder( name, isNode, outputPath ) {
	this.gypObject = emptySkeliton;
	this.isNode = isNode || false;		// Default to non-node configs
	this.name = name || "binding";		// Default our name to binding for node.js
	this.outputPath = outputPath || process.cwd() + "/" + this.name + "/";
}
285468
@Override
	public GlobalProcessor<T> buildProcessorChain(String processorKeys) {

		if (null == processorKeys)
			return null;
		else if (JawrConstant.EMPTY_GLOBAL_PREPROCESSOR_ID.equals(processorKeys))
			return new EmptyGlobalProcessor<>();

		StringTokenizer tk = new StringTokenizer(processorKeys, ",");

		AbstractChainedGlobalProcessor<T> chain = null;
		while (tk.hasMoreTokens())
			chain = addOrCreateChain(chain, tk.nextToken());

		return chain;
	}
42849
public SharedTreeSubgraph makeSubgraph(String name) {
    SharedTreeSubgraph sg = new SharedTreeSubgraph(subgraphArray.size(), name);
    subgraphArray.add(sg);
    return sg;
  }
473385
public static NodeImpl createPropertyNode(final String name, final NodeImpl parent) {
    return new NodeImpl( //
        name, //
        parent, //
        false, //
        null, //
        null, //
        ElementKind.PROPERTY, //
        EMPTY_CLASS_ARRAY, //
        null, //
        null, //
        null, //
        null //
    );
  }
637029
public static Object newInstance(String name) {
        try {
            return forName(name).newInstance();
        } catch (InstantiationException e) {
            throw new IllegalStateException(e.getMessage(), e);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
1185256
@Override
    public Processor newProcessor(Processor sourceProcessor) {
        LocalClustererProcessor newProcessor = new LocalClustererProcessor();
        LocalClustererProcessor originProcessor = (LocalClustererProcessor) sourceProcessor;
        if (originProcessor.getLearner() != null) {
            newProcessor.setLearner(originProcessor.getLearner().create());
        }
        newProcessor.setOutputStream(originProcessor.getOutputStream());
        return newProcessor;
    }
964844
void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
        Type type = node.getType();
        if (node instanceof MethodDeclaration && ("newBufferAndOffset".equals(name) || "nextArrayOffset".equals(name))) {
            node.setType(PrimitiveType.intType());
        } else if (PrimitiveType.longType().equals(type)) {
            switch(name) {
            case "offset":
            case "offsetInNew":
            case "offsetInOld":
            case "lookAheadElementOffset":
                node.setType(PrimitiveType.intType());
            }
        } else if (isRefType(type, "LinkedQueueNode")) {
            node.setType(simpleParametricType("LinkedQueueAtomicNode", "E"));
        } else if (isRefArray(type, "E")) {
            node.setType(atomicRefArrayType((ArrayType) type));
        }
    }