<p>
The elastic inference accelerator associated with the instance.
</p>

@param elasticInferenceAcceleratorAssociations
The elastic inference accelerator associated with the instance.
331160
public void setElasticInferenceAcceleratorAssociations(java.util.Collection<ElasticInferenceAcceleratorAssociation> elasticInferenceAcceleratorAssociations) {
        if (elasticInferenceAcceleratorAssociations == null) {
            this.elasticInferenceAcceleratorAssociations = null;
            return;
        }

        this.elasticInferenceAcceleratorAssociations = new com.amazonaws.internal.SdkInternalList<ElasticInferenceAcceleratorAssociation>(
                elasticInferenceAcceleratorAssociations);
    }
804615
protected void appendCapacityContextAwareWrapper(SarlCapacity source, JvmGenericType inferredJvmType) {
		final JvmGenericType innerType = this.typesFactory.createJvmGenericType();
		innerType.setInterface(false);
		innerType.setAbstract(false);
		innerType.setVisibility(JvmVisibility.PUBLIC);
		innerType.setStatic(true);
		innerType.setStrictFloatingPoint(false);
		innerType.setFinal(false);
		final String innerTypeName = Capacity.ContextAwareCapacityWrapper.class.getSimpleName();
		innerType.setSimpleName(innerTypeName);

		inferredJvmType.getMembers().add(innerType);

		this.typeBuilder.setDocumentation(innerType, "@ExcludeFromApidoc"); //$NON-NLS-1$

		final JvmTypeParameter typeParameter = this.typesFactory.createJvmTypeParameter();
		typeParameter.setName("C"); //$NON-NLS-1$
		final JvmUpperBound constraint = this.typesFactory.createJvmUpperBound();
		constraint.setTypeReference(this._typeReferenceBuilder.typeRef(inferredJvmType));
		typeParameter.getConstraints().add(constraint);
		innerType.getTypeParameters().add(typeParameter);

		final Iterator<JvmTypeReference> extendedTypeIterator = inferredJvmType.getExtendedInterfaces().iterator();
		if (extendedTypeIterator.hasNext()) {
			final JvmTypeReference extendedType = extendedTypeIterator.next();
			final JvmTypeReference superType = this._typeReferenceBuilder.typeRef(
					extendedType.getQualifiedName() + "$" + innerTypeName, //$NON-NLS-1$
					this._typeReferenceBuilder.typeRef(typeParameter));
			innerType.getSuperTypes().add(superType);
		}

		innerType.getSuperTypes().add(this._typeReferenceBuilder.typeRef(inferredJvmType));

		final JvmConstructor constructor = this.typesFactory.createJvmConstructor();
		constructor.setVisibility(JvmVisibility.PUBLIC);
		innerType.getMembers().add(constructor);
		final JvmFormalParameter parameter1 = this.typesFactory.createJvmFormalParameter();
		parameter1.setName("capacity"); //$NON-NLS-1$
		parameter1.setParameterType(this._typeReferenceBuilder.typeRef(typeParameter));
		constructor.getParameters().add(parameter1);
		final JvmFormalParameter parameter2 = this.typesFactory.createJvmFormalParameter();
		parameter2.setName("caller"); //$NON-NLS-1$
		parameter2.setParameterType(this._typeReferenceBuilder.typeRef(AgentTrait.class));
		constructor.getParameters().add(parameter2);
		setBody(constructor, it -> {
			it.append("super(capacity, caller);"); //$NON-NLS-1$
		});

		final Set<ActionPrototype> createdActions = new TreeSet<>();
		for (final JvmGenericType sourceType : Iterables.concat(
				Collections.singletonList(inferredJvmType),
				Iterables.transform(Iterables.skip(inferredJvmType.getExtendedInterfaces(), 1), it -> {
					return (JvmGenericType) it.getType();
				}))) {
			copyNonStaticPublicJvmOperations(sourceType, innerType, createdActions, (operation, it) -> {
				it.append("try {"); //$NON-NLS-1$
				it.newLine();
				it.append("  ensureCallerInLocalThread();"); //$NON-NLS-1$
				it.newLine();
				it.append("  "); //$NON-NLS-1$
				if (operation.getReturnType() != null && !Objects.equal("void", operation.getReturnType().getIdentifier())) { //$NON-NLS-1$
					it.append("return "); //$NON-NLS-1$
				}
				it.append("this.capacity."); //$NON-NLS-1$
				it.append(operation.getSimpleName());
				it.append("("); //$NON-NLS-1$
				boolean first = true;
				for (final JvmFormalParameter fparam : operation.getParameters()) {
					if (first) {
						first = false;
					} else {
						it.append(", "); //$NON-NLS-1$
					}
					it.append(fparam.getName());
				}
				it.append(");"); //$NON-NLS-1$
				it.newLine();
				it.append("} finally {"); //$NON-NLS-1$
				it.newLine();
				it.append("  resetCallerInLocalThread();"); //$NON-NLS-1$
				it.newLine();
				it.append("}"); //$NON-NLS-1$
			});
		}
	}
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);
                }
            }
        }
    }
671710
public void syncWith(PresentationModel sourcePresentationModel) {
        for (A targetAttribute : attributes) {
            Attribute sourceAttribute = sourcePresentationModel.getAt(targetAttribute.getPropertyName(), targetAttribute.getTag());
            if (sourceAttribute != null) targetAttribute.syncWith(sourceAttribute);
        }
    }
463508
@com.fasterxml.jackson.annotation.JsonProperty("assessmentRunArns")
    public void setAssessmentRunArns(java.util.Collection<String> assessmentRunArns) {
        if (assessmentRunArns == null) {
            this.assessmentRunArns = null;
            return;
        }

        this.assessmentRunArns = new java.util.ArrayList<String>(assessmentRunArns);
    }
527541
@Reference(name = "messageEndpointCollaborator",
               service = MessageEndpointCollaborator.class,
               cardinality = ReferenceCardinality.OPTIONAL,
               policy = ReferencePolicy.DYNAMIC,
               policyOption = ReferencePolicyOption.GREEDY)
    protected void setMessageEndpointCollaborator(ServiceReference<MessageEndpointCollaborator> reference) {
        messageEndpointCollaboratorRef.setReference(reference);
    }
576269
@Override
    public void merge(JMSDestinationDefinition annotation, Class<?> instanceClass, Member member) throws InjectionException {

        if (member != null) {
            // JMSDestinationDefinition is a class-level annotation only.
            throw new IllegalArgumentException(member.toString());
        }

        name = mergeAnnotationValue(name, isXmlNameSet, annotation.name(), JMSDestinationProperties.NAME.getAnnotationKey(), "");
        interfaceName = mergeAnnotationValue(interfaceName, isXmlInterfaceNameSet, annotation.interfaceName(), JMSDestinationProperties.INTERFACE_NAME.getAnnotationKey(), "");
        className = mergeAnnotationValue(className, isXmlclassNameSet, annotation.className(), JMSDestinationProperties.CLASS_NAME.getAnnotationKey(), "");
        description = mergeAnnotationValue(description, isXmlDescriptionSet, annotation.description(), JMSDestinationProperties.DESCRIPTION.getAnnotationKey(), "");
        destinationName = mergeAnnotationValue(destinationName, isXmlDestinationNameSet, annotation.destinationName(),
                                               JMSDestinationProperties.DESTINATION_NAME.getAnnotationKey(), "");
        resourceAdapter = mergeAnnotationValue(resourceAdapter, isXmlResourceAdapterSet, annotation.resourceAdapter(),
                                               JMSDestinationProperties.RESOURCE_ADAPTER.getAnnotationKey(), "");
        properties = mergeAnnotationProperties(properties, xmlProperties, annotation.properties());

    }
1045148
public void setIamInstanceProfileAssociations(java.util.Collection<IamInstanceProfileAssociation> iamInstanceProfileAssociations) {
        if (iamInstanceProfileAssociations == null) {
            this.iamInstanceProfileAssociations = null;
            return;
        }

        this.iamInstanceProfileAssociations = new com.amazonaws.internal.SdkInternalList<IamInstanceProfileAssociation>(iamInstanceProfileAssociations);
    }
623963
@Override
    public void associateConnection(
                                    Object connection,
                                    ManagedConnectionFactory mcf,
                                    ConnectionRequestInfo cri) throws ResourceException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(this, tc, "associateConnection");
        }
        /*
         * Get the subject information
         */
        Subject subject = (containerManagedAuth ? getFinalSubject(cri, mcf, this) : null);
        // Give the security helper a chance to finalize what subject
        // should be used. When ThreadIdentitySupport = NOTALLOWED the
        // original subject will be unchanged.

        //subject = securityHelper.finalizeSubject(subject, cri, inuseCM.cmConfig);
        /*
         * Call associate connection
         */
        associateConnection(mcf, subject, cri, connection);
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(this, tc, "associateConnection");
        }
    }
169335
public void setAssociationExecutionTargets(java.util.Collection<AssociationExecutionTarget> associationExecutionTargets) {
        if (associationExecutionTargets == null) {
            this.associationExecutionTargets = null;
            return;
        }

        this.associationExecutionTargets = new com.amazonaws.internal.SdkInternalList<AssociationExecutionTarget>(associationExecutionTargets);
    }
1047400
public void setAggregationAuthorizations(java.util.Collection<AggregationAuthorization> aggregationAuthorizations) {
        if (aggregationAuthorizations == null) {
            this.aggregationAuthorizations = null;
            return;
        }

        this.aggregationAuthorizations = new com.amazonaws.internal.SdkInternalList<AggregationAuthorization>(aggregationAuthorizations);
    }
1148060
private static void addMergeInclusions(JpaQueryExecutor<?> executor, QuerySpec querySpec) {
		ArrayDeque<String> attributePath = new ArrayDeque<>();
		Class<?> resourceClass = querySpec.getResourceClass();

		addMergeInclusions(attributePath, executor, resourceClass);
	}
1012079
@Override
    public void visitReference(JCMemberReference tree) {
        ReferenceTranslationContext localContext = (ReferenceTranslationContext)context;

        //first determine the method symbol to be used to generate the sam instance
        //this is either the method reference symbol, or the bridged reference symbol
        Symbol refSym = localContext.isSignaturePolymorphic()
                ? localContext.sigPolySym
                : tree.sym;

        //the qualifying expression is treated as a special captured arg
        JCExpression init;
        switch(tree.kind) {

            case IMPLICIT_INNER:    /** Inner :: new */
            case SUPER:             /** super :: instMethod */
                init = makeThis(
                    localContext.owner.enclClass().asType(),
                    localContext.owner.enclClass());
                break;

            case BOUND:             /** Expr :: instMethod */
                init = tree.getQualifierExpression();
                init = attr.makeNullCheck(init);
                break;

            case UNBOUND:           /** Type :: instMethod */
            case STATIC:            /** Type :: staticMethod */
            case TOPLEVEL:          /** Top level :: new */
            case ARRAY_CTOR:        /** ArrayType :: new */
                init = null;
                break;

            default:
                throw new InternalError("Should not have an invalid kind");
        }

        List<JCExpression> indy_args = init==null? List.nil() : translate(List.of(init), localContext.prev);


        //build a sam instance using an indy call to the meta-factory
        result = makeMetafactoryIndyCall(localContext, localContext.referenceKind(), refSym, indy_args);
    }
308702
protected void addAccessor(PathAccessor acc, Class<? extends BioPAXElement> clazz)
	{
		accessors.put(acc, clazz);
	}
196221
@Override
  public void process(CAS tcas) {

    final AnnotationComboIterator comboIterator = new AnnotationComboIterator(tcas,
        this.sentenceType, this.tokenType);

    for (AnnotationIteratorPair annotationIteratorPair : comboIterator) {
      
      final List<AnnotationFS> sentenceTokenAnnotationList = new LinkedList<AnnotationFS>();

      final List<String> sentenceTokenList = new LinkedList<String>();
      final List<String> additionalContextList = new LinkedList<String>();

      for (AnnotationFS tokenAnnotation : annotationIteratorPair.getSubIterator()) {

        sentenceTokenAnnotationList.add(tokenAnnotation);

        sentenceTokenList.add(tokenAnnotation.getFeatureValueAsString(lexemeFeature));
        
        additionalContextList.add(tokenAnnotation.getFeatureValueAsString(additionalContextFeature));
      }
      
      String[] toks = sentenceTokenList.toArray(new String[sentenceTokenList.size()]);
      
      String[][] additionalContext = new String[toks.length][2];
      
      int i = 0;
      for (String ac : additionalContextList) {
        if(ac != null) {
          if(ac.equals("P")) {
            additionalContext[i][1] = ac;
          } else {
            additionalContext[i][0] = ac;
          }
        }
        i++;
      }
      
      final List<String> posTags = Arrays.asList(this.posTagger.tag(toks, additionalContext));

      double posProbabilities[] = null;

      if (this.probabilityFeature != null) {
        posProbabilities = this.posTagger.probs();
      }

      final Iterator<String> posTagIterator = posTags.iterator();
      final Iterator<AnnotationFS> sentenceTokenIterator = sentenceTokenAnnotationList.iterator();

      int index = 0;
      while (posTagIterator.hasNext() && sentenceTokenIterator.hasNext()) {
        final String posTag = posTagIterator.next();
        final AnnotationFS tokenAnnotation = sentenceTokenIterator.next();

        tokenAnnotation.setStringValue(this.posFeature, posTag);

        if (posProbabilities != null) {
          tokenAnnotation.setDoubleValue(this.posFeature, posProbabilities[index]);
        }

        index++;
      }

      // log tokens with pos
      if (this.logger.isLoggable(Level.FINER)) {

        final StringBuilder sentenceWithPos = new StringBuilder();

        sentenceWithPos.append("\"");

        for (final AnnotationFS token : sentenceTokenAnnotationList) {
          sentenceWithPos.append(token.getCoveredText());
          sentenceWithPos.append('\\');
          sentenceWithPos.append(token.getStringValue(this.posFeature));
          sentenceWithPos.append(' ');
        }

        // delete last whitespace
        if (sentenceWithPos.length() > 1) // not 0 because it contains already the " char
          sentenceWithPos.setLength(sentenceWithPos.length() - 1);
        
        sentenceWithPos.append("\"");

        this.logger.log(Level.FINER, sentenceWithPos.toString());
      }
    }
  }
813046
public void loadAccessors(Class<?> targetClass, MappedField configuredField, MappedField targetField) {
		
		// First checks xml configuration
		xml.fillMappedField(configuredClass, configuredField)
		   .fillMappedField(targetClass, targetField)
		// fill target field with custom methods defined in the configured field
		   .fillOppositeField(configuredClass, configuredField, targetField);

		// If no present custom methods in XML, it checks annotations
		Annotation.fillMappedField(configuredClass,configuredField);
		Annotation.fillMappedField(targetClass,targetField);
		// fill target field with custom methods defined in the configured field
		Annotation.fillOppositeField(configuredClass,configuredField,targetField);
		
	}
584598
public void setElasticGpuSpecifications(java.util.Collection<ElasticGpuSpecification> elasticGpuSpecifications) {
        if (elasticGpuSpecifications == null) {
            this.elasticGpuSpecifications = null;
            return;
        }

        this.elasticGpuSpecifications = new com.amazonaws.internal.SdkInternalList<ElasticGpuSpecification>(elasticGpuSpecifications);
    }