ProcessInterfaceOperationType Method.
420426
public String processInterfaceOperationType(DescriptionType descriptionType, String interfaceName, InterfaceOperationType interfaceOperationType, boolean addAddress)
    {
        String name = interfaceOperationType.getName();
        String patern = interfaceOperationType.getPattern();
        String style = interfaceOperationType.getStyle();
        boolean bIsSafe = interfaceOperationType.isSafe();
        MessageRefType messageIn = null;
        MessageRefType messageOut = null;
        MessageRefType messageFault = null;
        
        for (Object nextElement : interfaceOperationType.getInputOrOutputOrInfault())
        {
            Object inputOrOutputType = null;
            if (nextElement instanceof JAXBElement)
                inputOrOutputType = ((JAXBElement)nextElement).getValue();
            if (inputOrOutputType instanceof MessageRefType)
            {
                if ("In".equalsIgnoreCase(((MessageRefType)inputOrOutputType).getMessageLabel()))
                    messageIn = (MessageRefType)inputOrOutputType;
                else if ("Out".equalsIgnoreCase(((MessageRefType)inputOrOutputType).getMessageLabel()))
                    messageOut = (MessageRefType)inputOrOutputType;
                else
                    messageFault = (MessageRefType)inputOrOutputType;
            }
        }
        
        BindingType binding = this.getBindingFromInterfaceName(descriptionType, interfaceName);
        
        EndpointType endpointType = this.getServiceEndpointFromInterfaceNBinding(descriptionType, interfaceName, binding);
        
        String address = endpointType.getAddress();
        
        // Note: Here I should probably go through the types and find the type, but I just do the quick and dirty
        String element = messageIn.getElement();
        String messageLabel = messageIn.getMessageLabel();
        String elementOut = messageOut.getElement();
        
        this.updateMessageProcessInfo(element, elementOut, null, bIsSafe, addAddress ? address : null);
        
        return address;
    }
935702
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSInt polling_interval_validator = new MPSInt();
		polling_interval_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 1);
		polling_interval_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 1000);
		polling_interval_validator.validate(operationType, polling_interval, "\"polling_interval\"");
		
		MPSString interval_unit_validator = new MPSString();
		interval_unit_validator.validate(operationType, interval_unit, "\"interval_unit\"");
		
	}
1009522
private AbstractManagedType<X> processInternal(Class<X> clazz, boolean isIdClass)
    {
        if (managedTypes.get(clazz) == null)
        {
            return buildManagedType(clazz, isIdClass);
        }
        else
        {
            return (AbstractManagedType<X>) managedTypes.get(clazz);
        }
    }
1208126
private void processDynamicPrivileged(ComponentNameSpaceConfiguration compNSConfig) throws InjectionException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "processDynamic");

        List<Class<?>> injectionClasses = compNSConfig.getInjectionClasses();
        if (isProcessDynamicNeeded(injectionClasses)) {
            Map<String, InjectionBinding<?>> completedInjectionBindings = new HashMap<String, InjectionBinding<?>>();
            for (InjectionBinding<?> binding : ivProcessedInjectionBindings) {
                completedInjectionBindings.put(binding.getJndiName(), binding);
            }

            // Process injection metadata for the new injection classes.
            InjectionProcessorContextImpl context = ivInjectionEngine.createInjectionProcessorContext();
            context.ivCompletedInjectionBindings = completedInjectionBindings;
            compNSConfig.setInjectionProcessorContext(context);
            ivInjectionEngine.processInjectionMetaData(compNSConfig, injectionClasses);

            // Add new processed injection bindings.  If this is the first time
            // we've done dynamic processing, copy the ArrayList to a Set to
            // avoid duplicates.
            if (!ivAnyProcessDynamic) {
                ivAnyProcessDynamic = true;
                ivProcessedInjectionBindings = new LinkedHashSet<InjectionBinding<?>>(ivProcessedInjectionBindings);
            }
            ivProcessedInjectionBindings.addAll(context.ivProcessedInjectionBindings);

            // Add new declared injection targets.
            Map<Class<?>, List<InjectionTarget>> declaredTargets = ivInjectionEngine.getDeclaredInjectionTargets(context.ivProcessedInjectionBindings);
            ivDeclaredInjectionTargets.putAll(declaredTargets);

            //clear the cached list of injection targets for the dynamic classes
            for (Class<?> injectionClass : injectionClasses) {
                ivInjectionTargetMap.remove(injectionClass);
            }

            // Now that injection targets are obtained, complete the context.
            context.metadataProcessingComplete();

            // Now that metadata has processed successfully, add all the classes
            // to the list of processed classes.
            if (ivProcessedInjectionClasses.size() <= svInjClassMapCacheSize) {
                ivProcessedInjectionClasses.addAll(injectionClasses);
            }
        }

        if (isTraceOn && tc.isDebugEnabled())
            Tr.exit(tc, "processDynamic");
    }
238114
public void addInterfaceOperationType(String strVersion, InterfaceType interfaceType, MessageProcessInfo recMessageProcessInfo)
    {
        InterfaceOperationType interfaceOperationType = wsdlFactory.createInterfaceOperationType();
        interfaceType.getOperationOrFaultOrFeature().add(wsdlFactory.createInterfaceTypeOperation(interfaceOperationType));
        String name = this.fixName(recMessageProcessInfo.getField(MessageProcessInfo.DESCRIPTION).toString());
        interfaceOperationType.setName(name);
        String pattern = this.getURIProperty(MESSAGE_PATTERN_URI);
        interfaceOperationType.setPattern(pattern);
        boolean safe = SAFE_DEFAULT;
        String safeValue = ((PropertiesField)recMessageProcessInfo.getField(MessageProcessInfo.PROPERTIES)).getProperty(MessageProcessInfo.SAFE);
        if (safeValue != null)
            safe = Boolean.parseBoolean(safeValue);
        interfaceOperationType.setSafe(safe);
        String style = ((PropertiesField)recMessageProcessInfo.getField(MessageProcessInfo.PROPERTIES)).getProperty(MESSAGE_STYLE_URI);
        if (style == null)
            style = this.getURIProperty(MESSAGE_STYLE_URI);
        interfaceOperationType.setStyle(style);
        MessageInfo recMessageInfo = this.getMessageIn(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            MessageRefType messageRefType = wsdlFactory.createMessageRefType();
            JAXBElement<MessageRefType> interfaceOperationTypeInput = wsdlFactory.createInterfaceOperationTypeInput(messageRefType);
            interfaceOperationType.getInputOrOutputOrInfault().add(interfaceOperationTypeInput);
            name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            String code = recMessageInfo.getField(MessageInfo.CODE).toString();
            if (code == null)
                code = name;
            String element = ((PropertiesField)recMessageInfo.getField(MessageInfo.MESSAGE_PROPERTIES)).getProperty(MessageInfo.ELEMENT);
            if (element == null)
                if (code != null)
                    element = code;
            String messageLabel = "In";
            messageRefType.setElement(element);
            messageRefType.setMessageLabel(messageLabel);
            messageRefType = wsdlFactory.createMessageRefType();
        }
        recMessageInfo = this.getMessageOut(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            MessageRefType messageRefType = wsdlFactory.createMessageRefType();
            JAXBElement<MessageRefType> interfaceOperationTypeOutput = wsdlFactory.createInterfaceOperationTypeOutput(messageRefType);
            interfaceOperationType.getInputOrOutputOrInfault().add(interfaceOperationTypeOutput);
            name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            String code = recMessageInfo.getField(MessageInfo.CODE).toString();
            if (code == null)
                code = name;
            String element = ((PropertiesField)recMessageInfo.getField(MessageInfo.MESSAGE_PROPERTIES)).getProperty(MessageInfo.ELEMENT);
            if (element == null)
                if (code != null)
                    element = code;
            String messageLabel = "Out";
            messageRefType.setElement(element);
            messageRefType.setMessageLabel(messageLabel);
        }
    }
546783
@Override
  public OperationHandle getTypeInfo(SessionHandle sessionHandle) throws HiveSQLException {
    try {
      TGetTypeInfoReq req = new TGetTypeInfoReq(sessionHandle.toTSessionHandle());
      TGetTypeInfoResp resp = cliService.GetTypeInfo(req);
      checkStatus(resp.getStatus());
      TProtocolVersion protocol = sessionHandle.getProtocolVersion();
      return new OperationHandle(resp.getOperationHandle(), protocol);
    } catch (HiveSQLException e) {
      throw e;
    } catch (Exception e) {
      throw new HiveSQLException(e);
    }
  }
75285
void processOperation(HierarchyWrapperOperation operation) {
        // Hook for start
        operation.startOfProcess();

        // Hook to process other content (newlines and comments)
        otherContentList.forEach(operation::processOtherContent);

        if (elementContent != null && elementContent.isContentElement()) {
            // Hook to process element
            operation.processElement(elementContent);
        }

        // Hook to manipulate the order of the children
        operation.manipulateChildElements(children);

        // Hook to modify the operation before traversing sub levels
        HierarchyWrapperOperation subOperation = operation.createSubOperation();

        for (HierarchyWrapper child : children) {
            child.processOperation(subOperation);
        }

        // Hook for end of process
        operation.endOfProcess();
    }
1157246
@Override
    public void processXML()
                    throws InjectionException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "processXML");

        // Process all of the corresponding XML types in no particular
        // order other than it is the same as in prior releases.

        List<? extends EnvEntry> envEntries = ivNameSpaceConfig.getEnvEntries();
        if (envEntries != null)
        {
            processXMLEnvEntries(envEntries);
        }

        List<? extends ResourceRef> resourceRefs = ivNameSpaceConfig.getResourceRefs();
        if (resourceRefs != null)
        {
            processXMLResourceRefs(resourceRefs);
        }

        List<? extends ResourceEnvRef> resourceEnvRefs = ivNameSpaceConfig.getResourceEnvRefs();
        if (resourceEnvRefs != null)
        {
            processXMLResourceEnvRefs(resourceEnvRefs);
        }

        List<? extends MessageDestinationRef> msgDestRefs = ivNameSpaceConfig.getMsgDestRefs();
        if (msgDestRefs != null)
        {
            processXMLMsgDestRefs(msgDestRefs);
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "processXML");
    }
1071339
function processType (item, entities, types) {
  var type = _.find(types, { name: item })

  var additionalTypes = []
  // get the type names of the union or interface's possible types, given its type name
  var addPossibleTypes = typeName => {
    var union = _.find(types, { name: typeName })
    var possibleTypes = _.map(union.possibleTypes, 'name')

    // we must also process the union/interface type, as well as its possible types
    additionalTypes = _.union(additionalTypes, possibleTypes, [typeName])
  }

  var fields = _.map(type.fields, field => {
    var obj = analyzeField.call(this, field)

    if (
      (obj.isUnionType && !this.theme.unions.hide) ||
      (obj.isInterfaceType && !this.theme.interfaces.hide)
    ) {
      addPossibleTypes(obj.type)
    }

    // process args
    if (!this.theme.field.noargs) {
      if (field.args && field.args.length) {
        obj.args = _.map(field.args, analyzeField.bind(this))
      }
    }

    return obj
  })

  entities[type.name] = {
    name: type.name,
    fields: fields,
    isObjectType: true,
    isInterfaceType: type.kind === 'INTERFACE',
    isUnionType: type.kind === 'UNION',
    possibleTypes: _.map(type.possibleTypes, 'name')
  }

  var linkeditems = _.chain(fields)
    .filter('isObjectType')
    .map('type')
    .union(additionalTypes)
    .uniq()
    .value()

  return linkeditems
}
402948
def type_to_interface(event_type):
    """"""
    global _lookup
    if not isinstance(event_type, library.VBoxEventType):
        raise TypeError("event_type was not of VBoxEventType")
    if not _lookup:
        for attr in dir(library):
            event_interface = getattr(library, attr)
            if not inspect.isclass(event_interface):
                continue
            if not issubclass(event_interface, library.Interface):
                continue
            et = getattr(event_interface, 'id', None)
            if et is None:
                continue
            if not isinstance(et, library.VBoxEventType):
                continue
            _lookup[int(et)] = event_interface
    return _lookup[int(event_type)]
181890
protected function processOperation()
    {
        if ($this->_operation!==null) {
            $value = $this->_operationArgument ? $this->_operationArgument : null;
            if ($value instanceof TmpFile) {
                $value = (string) $value;
            }
            $this->addArg($this->_operation, $value, $this->_escapeOperationArgument);
        }
    }
497363
@Override
    public void processEvent(SystemEvent event) throws AbortProcessingException {
        final UIViewRoot source = (UIViewRoot) event.getSource();

        final FacesContext context = FacesContext.getCurrentInstance();
        final WebXmlParameters webXmlParameters = new WebXmlParameters(context.getExternalContext());
        final boolean provideJQuery = webXmlParameters.isProvideJQuery();
        final boolean provideBootstrap = webXmlParameters.isProvideBoostrap();
        final boolean useCompressedResources = webXmlParameters.isUseCompressedResources();
        final boolean disablePrimeFacesJQuery = webXmlParameters.isIntegrationPrimeFacesDisableJQuery();

        final List<UIComponent> resources = new ArrayList<>(source.getComponentResources(context, HEAD));
        // Production mode and compressed
        if (useCompressedResources && context.getApplication().getProjectStage() == ProjectStage.Production) {
            handleCompressedResources(context, provideJQuery, provideBootstrap, resources, source);
        } else {
            handleConfigurableResources(context, provideJQuery, provideBootstrap, resources, source);
        }

        if (disablePrimeFacesJQuery) {
            for (UIComponent resource : resources) {
                final String resourceLibrary = (String) resource.getAttributes().get("library");
                final String resourceName = (String) resource.getAttributes().get("name");
                if ("primefaces".equals(resourceLibrary) && "jquery/jquery.js".equals(resourceName)) {
                    source.removeComponentResource(context, resource);
                }
            }
        }
    }
1093377
@SuppressWarnings( "unchecked" )
    protected void processParametersOfMethodDeclaration( MethodDeclaration methodDeclaration,
                                                         MethodMetadata methodMetadata ) {
        for (SingleVariableDeclaration singleVariableDeclaration : (List<SingleVariableDeclaration>)methodDeclaration.parameters()) {
            Type type = singleVariableDeclaration.getType();

            if (type.isPrimitiveType()) {
                FieldMetadata primitiveFieldMetadata = processVariableDeclaration(singleVariableDeclaration, type);
                methodMetadata.getParameters().add(primitiveFieldMetadata);
            }
            if (type.isParameterizedType()) {
                FieldMetadata parameterizedTypeFieldMetadata = processVariableDeclaration(singleVariableDeclaration, type);
                methodMetadata.getParameters().add(parameterizedTypeFieldMetadata);
            }
            if (type.isQualifiedType()) {
                // TODO
            }
            if (type.isSimpleType()) {
                FieldMetadata simpleTypeFieldMetadata = processVariableDeclaration(singleVariableDeclaration, type);
                methodMetadata.getParameters().add(simpleTypeFieldMetadata);
            }
            if (type.isArrayType()) {
                FieldMetadata arrayTypeFieldMetadata = processVariableDeclaration(singleVariableDeclaration, type);
                methodMetadata.getParameters().add(arrayTypeFieldMetadata);
            }
            if (type.isWildcardType()) {
                // TODO
            }
        }

    }
118373
public void addProcessForWSDL(String strVersion, Object typeObject, MessageProcessInfo recMessageProcessInfo, OperationType type)
    {
        if (type == OperationType.BINDING_OPERATIONS)
            this.addBindingOperationType(strVersion, (TBinding)typeObject, recMessageProcessInfo);
        else if (type == OperationType.INTERFACE_OPERATIONS)
            this.addInterfaceOperationType(strVersion, (TPortType)typeObject, recMessageProcessInfo);
        else if (type == OperationType.MESSAGE_OPERATIONS)
            this.addMessageType(strVersion, (TDefinitions)typeObject, recMessageProcessInfo);
        else if (type == OperationType.TYPES_OPERATIONS)
            this.addTypeType(strVersion, (TTypes)typeObject, recMessageProcessInfo);
    }
74692
void processAnnotatedType(@Observes ProcessAnnotatedType<DefaultHystrixConcurrencyStrategy> event) {
        event.configureAnnotatedType()
                .filterFields(field -> "managedThreadFactory".equals(field.getJavaMember().getName()))
                .forEach(field -> {
                    field.remove(annotation -> Resource.class.equals(annotation.annotationType()));
                    field.add(ResourceLiteral.lookup("java:jboss/ee/concurrency/factory/default"));
                });
    }
624683
private <A extends Annotation> void processMemberAnnotations(int processorIndex,
                                                                 InjectionProcessorProvider<A, ?> provider,
                                                                 Member[] members,
                                                                 AnnotatedElement[] annotatedMembers)
                    throws InjectionException
    {
        Class<A> annClass = provider.getAnnotationClass();
        if (annClass != null)
        {
            for (int i = 0; i < members.length; i++)
            {
                A ann = annotatedMembers[i].getAnnotation(annClass);
                if (ann != null)
                {
                    Member member = members[i];
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        Tr.debug(tc, "found member annotation " + toStringSecure(ann) + " on " + member);

                    InjectionProcessor<A, ?> processor = getProcessor(processorIndex, provider);
                    addOrMergeInjectionBinding(processorIndex, processor, member.getDeclaringClass(), member, ann);
                }
            }
        }
    }
834898
public static AGeneralOperation getOperation(OperationType operationType){
		switch(operationType){
			case BASIC_INSTRUCTION:			   return new BasicOperation();			
			case BASIC_CONVERSION:             return new BasicConversion();			
			case OBJECT:					   return new ObjectOperation();			
			case ARRAY: 					   return new ArrayOperation();			
			case ARRAY_LIST:				   return new ArrayListOperation();		
			case LIST_ARRAY:			       return new ListArrayOperation();		
			case ARRAY_WITH_MAPPED_ITEMS:	   return new MappedArrayOperation();		
			case ARRAY_LIST_WITH_MAPPED_ITEMS: return new MappedArrayListOperation();	
			case LIST_ARRAY_WITH_MAPPED_ITEMS: return new MappedListArrayOperation();	
			case COLLECTION: 				   return new CollectionOperation();		
			case COLLECTION_WITH_MAPPED_ITEMS: return new MappedCollectionOperation();	
			case MAP:	     				   return new MapOperation();				
			case MAP_WITH_MAPPED_ITEMS: 	   return new MappedMapOperation();		
			case CONVERSION: 				   return new ConversionOperation();
			case DATE_CALENDAR:				   return new DateCalendarOperation();
			case STRING_ENUM: 				   return new StringEnumOperation();
			case STRING_STRINGBUFFER:		   return new StringStringBufferOperation();
			case STRING_STRINGBUILDER:		   return new StringStringBuilderOperation();
			case CALENDAR_DATE:				   return new CalendarDateOperation();
			case ENUM_STRING:				   return new EnumStringOperation();
			case STRINGBUILDER_STRING:         return new StringBuilderStringOperation();
			case STRINGBUFFER_STRING:		   return new StringBufferStringOperation();
			case ENUM_ENUM: 				   return new EnumEnumOperation();
			default: return null;
		}
		
	}