Handles POD types nodes.
        see init_fundamental_types for the registration.
195752
def _handle_fundamental_types(self, typ):
        
        ctypesname = self.get_ctypes_name(typ.kind)
        if typ.kind == TypeKind.VOID:
            size = align = 1
        else:
            size = typ.get_size()
            align = typ.get_align()
        return typedesc.FundamentalType(ctypesname, size, align)
1357151
private void handleIdentifyNodeResponse(SerialMessage incomingMessage) {
		logger.trace("Handle Message Get Node ProtocolInfo Response");
		
		int nodeId = lastSentMessage.getMessagePayloadByte(0);
		logger.debug("ProtocolInfo for Node = " + nodeId);
		
		boolean listening = (incomingMessage.getMessagePayloadByte(0) & 0x80)!=0 ? true : false;
		boolean routing = (incomingMessage.getMessagePayloadByte(0) & 0x40)!=0 ? true : false;
		int version = (incomingMessage.getMessagePayloadByte(0) & 0x07) + 1;
		logger.debug("Listening = " + listening);
		logger.debug("Routing = " + routing);
		logger.debug("Version = " + version);
		
		this.zwaveNodes.get(nodeId).setListening(listening);
		this.zwaveNodes.get(nodeId).setRouting(routing);
		this.zwaveNodes.get(nodeId).setVersion(version);

		ZWaveDeviceClass.Basic basic = ZWaveDeviceClass.Basic.getBasic(incomingMessage.getMessagePayloadByte(3));
		if (basic == null) {
			logger.error(String.format("Basic device class 0x%02x not found", incomingMessage.getMessagePayloadByte(3)));
			return;
		}
		ZWaveDeviceClass.Generic generic = ZWaveDeviceClass.Generic.getGeneric(incomingMessage.getMessagePayloadByte(4));
		if (generic == null) {
			logger.error(String.format("Generic device class 0x%02x not found", incomingMessage.getMessagePayloadByte(4)));
			return;
		}
		ZWaveDeviceClass.Specific specific = ZWaveDeviceClass.Specific.getSpecific(generic, incomingMessage.getMessagePayloadByte(5));
		if (specific == null) {
			logger.error(String.format("Specific device class 0x%02x not found", incomingMessage.getMessagePayloadByte(5)));
			return;
		}
		logger.debug(String.format("Basic = %s 0x%02x", basic.getLabel(), basic.getKey()));
		logger.debug(String.format("Generic = %s 0x%02x", generic.getLabel(), generic.getKey()));
		logger.debug(String.format("Specific = %s 0x%02x", specific.getLabel(), specific.getKey()));
		
		ZWaveDeviceClass deviceClass = this.zwaveNodes.get(nodeId).getDeviceClass();
		deviceClass.setBasicDeviceClass(basic);
		deviceClass.setGenericDeviceClass(generic);
		deviceClass.setSpecificDeviceClass(specific);
		
		// Add mandatory command classes as specified by it's generic device class.
		for (ZWaveCommandClass.CommandClass commandClass : generic.getMandatoryCommandClasses()) {
			ZWaveCommandClass zwaveCommandClass = ZWaveCommandClass.getInstance(commandClass.getKey(), this.zwaveNodes.get(nodeId), this);
			if (zwaveCommandClass != null)
				this.zwaveNodes.get(nodeId).addCommandClass(zwaveCommandClass);
		}

		// Add mandatory command classes as specified by it's specific device class.
		for (ZWaveCommandClass.CommandClass commandClass : specific.getMandatoryCommandClasses()) {
			ZWaveCommandClass zwaveCommandClass = ZWaveCommandClass.getInstance(commandClass.getKey(), this.zwaveNodes.get(nodeId), this);
			if (zwaveCommandClass != null)
				this.zwaveNodes.get(nodeId).addCommandClass(zwaveCommandClass);
		}
		
		// Add the WAKE_UP command class to this node, since it's not listening.
		if (!listening) {
			ZWaveCommandClass zwaveCommandClass = ZWaveCommandClass.getInstance(ZWaveCommandClass.CommandClass.WAKE_UP.getKey(), this.zwaveNodes.get(nodeId), this);
			if (zwaveCommandClass != null)
				this.zwaveNodes.get(nodeId).addCommandClass(zwaveCommandClass);
		}

    	// advance node stage of the current node.
		this.getNode(nodeId).advanceNodeStage();
	}
86895
def base_type
      n = NodeCache.find(attributes["type"])
      n.is_a?(Type) ? n.base_type : n
    end
832259
protected function initializeNodeTemplates()
    {
        $this->nodeType = $this->nodeTypeManager->getNodeType($this->nodeTypeName);
        $this->nodeTemplate = new NodeTemplate();
        $this->nodeTemplate->setNodeType($this->nodeType);
    }
1116799
function handlerReducersForType(type:String) {
  let apiActionTypes = getApiTypes(type);
  let reducers = {};
  let namesToState = {};
  apiActionTypes.forEach((key, idx) => {
    reducers[apiActionTypes[idx]] = apiReducers[apiStates[idx]];
    namesToState[upcase(apiStates[idx])] = toApiKey(apiActionTypes[idx]);
  });
  return {reducers, namesToState};
}
864656
public void visit(ASTNode[] nodes, SourceUnit source) {
        if (!(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) {
            throw new RuntimeException("Internal error: wrong types: $node.class / $parent.class");
        }
        AnnotationNode node = (AnnotationNode) nodes[0];
        AnnotatedNode parent = (AnnotatedNode) nodes[1];

        if (VetoableASTTransformation.hasVetoableAnnotation(parent)) {
            // VetoableASTTransformation will handle both @Bindable and @Vetoable
            return;
        }

        ClassNode declaringClass = parent.getDeclaringClass();
        if (parent instanceof FieldNode) {
            if ((((FieldNode) parent).getModifiers() & Opcodes.ACC_FINAL) != 0) {
                source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage(
                        new SyntaxException("@groovy.beans.Bindable cannot annotate a final property.",
                                node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()),
                        source));
            }

            if (VetoableASTTransformation.hasVetoableAnnotation(parent.getDeclaringClass())) {
                // VetoableASTTransformation will handle both @Bindable and @Vetoable
                return;
            }
            addListenerToProperty(source, node, declaringClass, (FieldNode) parent);
        } else if (parent instanceof ClassNode) {
            addListenerToClass(source, (ClassNode) parent);
        }
    }
995108
def parse_children(self, node):
        

        if 'name' in node.lattrib:
            name = node.lattrib['name']
        else:
            self.raise_error('<Children> must specify a name.')

        if 'type' in node.lattrib:
            type_ = node.lattrib['type']
        else:
            self.raise_error("Children '{0}' must specify a type.", name)

        self.current_component_type.add_children(Children(name, type_, True))
518603
def _handle_nodes(nodes: MaybeNodeList) -> List[BaseEntity]:
    """"""
    if isinstance(nodes, BaseEntity):
        return [nodes]

    return [
        (
            parse_result_to_dsl(node)
            if not isinstance(node, BaseEntity) else
            node
        )
        for node in nodes
    ]
289703
private void addLastOfType() {
		for (Node node : nodes) {
			Index index = helper.getIndexInParent(node, true);
			if (index.index == (index.size-1))
				result.add(node);
		}
	}
155993
protected void initJspConfig(XmlParser.Node node)
    {
        for (int i=0;i<node.size();i++)
        {
            Object o=node.get(i);
            if (o instanceof XmlParser.Node && "taglib".equals(((XmlParser.Node)o).getTag()))
                initTagLib((XmlParser.Node)o);
        }
    }
391217
def _handle_typename(self, node, scope, ctxt, stream):
        
        self._dlog("handling typename")

        return self._handle_node(node.type, scope, ctxt, stream)
41192
function() {
      // Instantiate the parsers; this will register handlers for known events
      var allTypeInfos = tr.e.importer.linux_perf.
          Parser.getAllRegisteredTypeInfos();
      var parsers = allTypeInfos.map(
          function(typeInfo) {
            return new typeInfo.constructor(this);
          }, this);

      return parsers;
    }
1077949
private void registerListType(PContainer containerType) {
        PDescriptor itemType = containerType.itemDescriptor();
        if (itemType.getType() == PType.MAP ||
            itemType.getType() == PType.LIST ||
            itemType.getType() == PType.SET) {
            registerListType((PContainer) itemType);
        } else if (itemType.getType() == PType.ENUM ||
                   itemType.getType() == PType.MESSAGE){
            registerRecursively((PDeclaredDescriptor<?>) itemType);
        }
        if (containerType instanceof PMap) {
            PDescriptor keyType = ((PMap) containerType).keyDescriptor();
            if (keyType.getType() == PType.ENUM ||
                keyType.getType() == PType.MESSAGE){
                registerRecursively((PDeclaredDescriptor<?>) keyType);
            }
        }
        // Else ignore.
    }
1015924
def parse_on_start(self, node):
        

        event_handler = OnStart()

        self.current_regime.add_event_handler(event_handler)

        self.current_event_handler = event_handler
        self.process_nested_tags(node)
        self.current_event_handler = None
490621
private void ensureTyped(Node n, JSType type) {
    // Make sure FUNCTION nodes always get function type.
    checkState(!n.isFunction() || type.isFunctionType() || type.isUnknownType());
    if (n.getJSType() == null) {
      n.setJSType(type);
    }
  }
43294
private void initRemoteCommands()
   {
      this.id = UUID.randomUUID().toString();
      registerNodeTypes = rpcService.registerCommand(new RemoteCommand()
      {

         public String getId()
         {
            return "org.exoplatform.services.jcr.impl.core.nodetype.NodeTypeDataManagerImpl-registerNodeTypes-"
               + repositoryName;
         }

         public Serializable execute(Serializable[] args) throws Throwable
         {
            if (!id.equals(args[0]))
            {
               try
               {
                  String[] names = (String[])args[1];
                  final List<NodeTypeData> allNodeTypes = new ArrayList<NodeTypeData>();
                  for (int i = 0; i < names.length; i++)
                  {
                     NodeTypeData nodeType = persister.getNodeType(InternalQName.parse(names[i]));
                     if (nodeType != null)
                        allNodeTypes.add(nodeType);
                  }
                  // register nodetypes in runtime
                  final Map<InternalQName, NodeTypeData> volatileNodeTypes = new HashMap<InternalQName, NodeTypeData>();
                  //create map from list
                  for (final NodeTypeData nodeTypeData : allNodeTypes)
                  {
                     volatileNodeTypes.put(nodeTypeData.getName(), nodeTypeData);
                  }

                  for (final NodeTypeData nodeTypeData : allNodeTypes)
                  {
                     nodeTypeRepository.addNodeType(nodeTypeData, volatileNodeTypes);
                     for (NodeTypeManagerListener listener : listeners.values())
                     {
                        listener.nodeTypeRegistered(nodeTypeData.getName());
                     }
                  }
               }
               catch (Exception e)
               {
                  LOG.warn("Could not register the node types", e);
               }
            }
            return true;
         }
      });
      unregisterNodeType = rpcService.registerCommand(new RemoteCommand()
      {

         public String getId()
         {
            return "org.exoplatform.services.jcr.impl.core.nodetype.NodeTypeDataManagerImpl-unregisterNodeType-"
               + repositoryName;
         }

         public Serializable execute(Serializable[] args) throws Throwable
         {
            if (!id.equals(args[0]))
            {
               try
               {
                  String name = (String)args[1];
                  NodeTypeData nodeType = nodeTypeRepository.getNodeType(InternalQName.parse(name));
                  if (nodeType != null)
                  {
                     nodeTypeRepository.removeNodeType(nodeType);

                     for (NodeTypeManagerListener listener : listeners.values())
                     {
                        listener.nodeTypeUnregistered(nodeType.getName());
                     }
                  }
               }
               catch (Exception e)
               {
                  LOG.warn("Could not register the node type", e);
               }
            }
            return true;
         }
      });
   }
233661
def _handle_identifier_type(self, node, scope, ctxt, stream):
        
        self._dlog("handling identifier")

        cls = self._resolve_to_field_class(node.names, scope)
        return cls