Set this item to an InvokeDynamic item.

@param name
invokedynamic's name.
@param desc
invokedynamic's descriptor.
@param bsm
bootstrap method.
@param bsmArgs
bootstrap method constant arguments.
422823
void set(final String name, final String desc, final Handle bsm,
            final Object[] bsmArgs) {
        this.type = 'y';
        this.strVal1 = name;
        this.strVal2 = desc;
        this.objVal3 = bsm;
        this.objVals = bsmArgs;

        int hashCode = 'y' + name.hashCode() * desc.hashCode() * bsm.hashCode();
        for (int i = 0; i < bsmArgs.length; i++) {
            hashCode *= bsmArgs[i].hashCode();
        }
        this.hashCode = 0x7FFFFFFF & hashCode;
    }
529667
@Override
	public void setName(String name) {
		if (name == null) {
			super.setName(getFirstFreeBusLineName(getContainer()));
		} else {
			super.setName(name);
		}
	}
1331212
@Override
  public final void setItem(final SeGoods pSeGoods) {
    this.item = pSeGoods;
    if (this.itsId == null) {
      this.itsId = new SeGoodsPriceId();
    }
    this.itsId.setItem(this.item);
  }
382371
public static TypeSignature ofNamed(String name, Object namedTypeDescriptor) {
        return new TypeSignature(requireNonNull(name, "name"),
                                 requireNonNull(namedTypeDescriptor, "namedTypeDescriptor"));
    }
598236
public void setDynamicParameters(Set<String> dynamicParams) {

        if (dynamicParams == null) {
            dynamicParams = Sets.newHashSet();
        }
        m_dynamicParameters = dynamicParams;
    }
1365650
public static CallSite callLambdaMetaFactory(ReloadableType rtype, Object[] bsmArgs, Object lookup,
			String indyNameAndDescriptor, Class<?> executorClass) throws Exception {
		MethodHandles.Lookup caller = (MethodHandles.Lookup) lookup;

		ClassLoader callerLoader = caller.lookupClass().getClassLoader();

		int descriptorStart = indyNameAndDescriptor.indexOf('(');
		String invokedName = indyNameAndDescriptor.substring(0, descriptorStart);
		MethodType invokedType = MethodType.fromMethodDescriptorString(
				indyNameAndDescriptor.substring(descriptorStart), callerLoader);

		// Use bsmArgs to build the parameters
		MethodType samMethodType = MethodType.fromMethodDescriptorString(
				(((Type) bsmArgs[0]).getDescriptor()), callerLoader);

		Handle bsmArgsHandle = (Handle) bsmArgs[1];
		String owner = bsmArgsHandle.getOwner();
		String name = bsmArgsHandle.getName();
		String descriptor = bsmArgsHandle.getDesc();
		MethodType implMethodType = MethodType.fromMethodDescriptorString(descriptor, callerLoader);
		// Looking up the lambda$run method in the caller class (note the caller class is the executor, which gets us around the
		// problem of having to hack into LambdaMetafactory to intercept reflection)
		MethodHandle implMethod = null;
		switch (bsmArgsHandle.getTag()) {
			case Opcodes.H_INVOKESTATIC:
				implMethod = caller.findStatic(caller.lookupClass(), name, implMethodType);
				break;
			case Opcodes.H_INVOKESPECIAL:
				// If there is an executor, the lambda function is actually modified from 'private instance' to 'public static' so adjust lookup. The method
				// will be static with a new leading parameter.
				if (executorClass == null) {
					// TODO is final parameter here correct?
					implMethod = caller.findSpecial(caller.lookupClass(), name, implMethodType, caller.lookupClass());
				}
				else {
					implMethod = caller.findStatic(caller.lookupClass(), name, MethodType.fromMethodDescriptorString(
							"(L" + owner + ";" + descriptor.substring(1), callerLoader));
				}
				break;
			case Opcodes.H_INVOKEVIRTUAL:
				// There is a possibility to 'shortcut' here. Basically we are trying to resolve a callsite reference
				// to the method that satisfies it. The easiest option is to just find the method on the originally
				// loaded version of the target class and return that. A more optimal shortcut could return the
				// method on the executor class if the target has been reloaded (effectively bypassing the method
				// on the originally loaded version since we know that it will be acting as a pass through). But this
				// opens up a can of worms related to visibility. The executor is loaded into the child classloader,
				// and if the caller has not been reloaded it will not be able to 'see' the executor (since it is in
				// a child classloader). So, basically keep this dumb (but reliable) for now.

				TypeRegistry typeRegistry = rtype.getTypeRegistry();
				ReloadableType ownerRType = typeRegistry.getReloadableType(owner);
				if (null == ownerRType || !ownerRType.hasBeenReloaded()) {
					// target containing the reference/lambdaMethod has not been reloaded, no need to get over
					// complicated.
					Class<?> clazz = callerLoader.loadClass(owner.replace("/", "."));
					implMethod = caller.findVirtual(clazz, name, implMethodType);
				}
				else {
					MethodMember targetReferenceMethodMember = ownerRType.getCurrentMethod(name, descriptor);
					String targetReferenceDescriptor = targetReferenceMethodMember.getDescriptor();
					MethodType targetReferenceMethodType = MethodType.fromMethodDescriptorString(
							targetReferenceDescriptor, callerLoader);
					Class<?> targetReferenceClass = ownerRType.getClazz();
					MethodMember currentMethod = ownerRType.getCurrentMethod(name, descriptor);

					if (currentMethod.original == null) {
						// null means this method did not exist on the original version of the target.
						// Assert that the caller must have been reloaded, otherwise how would it
						// have a reference to something that did not exist on the first version of the type. In that
						// case we know we can return the method on the executor class because both the reloaded
						// caller and reloaded target are in the same child classloader (no visibility problem).
						if (!rtype.hasBeenReloaded()) {
							throw new IllegalStateException(
									"Assertion violated: When a method added on reload is being referenced"
											+ "in target type '" + ownerRType.getName()
											+ "', expected the caller to also have been reloaded: '"
											+ rtype.getName() + "'");
						}
						CurrentLiveVersion ownerLiveVersion = ownerRType.getLiveVersion();
						Class<?> ownerExecutorClass = ownerLiveVersion.getExecutorClass();
						Method executorMethod = ownerLiveVersion.getExecutorMethod(currentMethod);
						String methodDescriptor = Type.getType(executorMethod).getDescriptor();
						MethodType type = MethodType.fromMethodDescriptorString(methodDescriptor, callerLoader);
						implMethod = caller.findStatic(ownerExecutorClass, name, type);
					}
					else {
						// This finds the reference method on the originally loaded class. It will pass through
						// to the actual code on the reloaded version.
						implMethod = caller.findVirtual(targetReferenceClass, name, targetReferenceMethodType);
					}
				}
				break;
			case Opcodes.H_NEWINVOKESPECIAL:
				Class<?> clazz = callerLoader.loadClass(owner.replace("/", "."));
				implMethod = caller.findConstructor(clazz, implMethodType);
				break;
			case Opcodes.H_INVOKEINTERFACE:
				Handle h = (Handle) bsmArgs[1];
				String interfaceOwner = h.getOwner();
				// TODO Should there not be a more direct way to this than classloading?
				// TODO What about when this is a method added to the interface on a reload? It won't really exist, should we point
				// to the executor? or something else? (maybe just directly the real method that will satisfy the interface - if it can be worked out)
				Class<?> interfaceClass = callerLoader.loadClass(interfaceOwner.replace('/', '.')); // interface type, eg StreamB$Foo
				implMethod = caller.findVirtual(interfaceClass, name, implMethodType);
				break;
			default:
				throw new IllegalStateException("nyi " + bsmArgsHandle.getTag());
		}

		MethodType instantiatedMethodType = MethodType.fromMethodDescriptorString(
				(((Type) bsmArgs[2]).getDescriptor()), callerLoader);

		return LambdaMetafactory.metafactory(caller, invokedName, invokedType, samMethodType, implMethod,
				instantiatedMethodType);

	}
876604
public void assignProvidedProperties(ComponentDescriptor<?> descriptor, Object component) {
        AssignProvidedCallback callback = new AssignProvidedCallback(_injectionManager);
        callback.onEvent(component, descriptor);
    }
581838
private void setRenderArgs(ITemplate t, Object... args) {
        if (null == args) {
            t.__setRenderArg(0, null);
        } else if (1 == args.length) {
            Object o0 = args[0];
            if (o0 instanceof Map) {
                t.__setRenderArgs((Map<String, Object>) args[0]);
            } else if (o0 instanceof JSONWrapper) {
                t.__setRenderArg((JSONWrapper) o0);
            } else {
                t.__setRenderArgs(args);
            }
        } else {
            t.__setRenderArgs(args);
        }
        //if (mode.isDev()) cceCounter.remove();
    }
523184
@Override
	public Response setDescription( String applicationName, String desc ) {

		this.logger.fine( "Request: change the description of " + applicationName + "." );
		Response response = Response.ok().build();
		String lang = lang( this.manager );
		try {
			ManagedApplication ma = this.manager.applicationMngr().findManagedApplicationByName( applicationName );
			if( ma == null ) {
				response = handleError(
						Status.NOT_FOUND,
						new RestError( REST_INEXISTING, application( applicationName )),
						lang ).build();

			} else {
				this.manager.applicationMngr().updateApplication( ma, desc );
			}

		} catch( IOException e ) {
			response = RestServicesUtils.handleError(
					Status.FORBIDDEN,
					new RestError( ErrorCode.REST_UNDETAILED_ERROR, e ),
					lang ).build();
		}

		return response;
	}
1263984
@Override
    public boolean setInitParameter(String name, String value) throws IllegalStateException, IllegalArgumentException {
        if (name == null) {
            logger.logp(Level.SEVERE, CLASS_NAME, "setInitParameter", servlet40NLS.getString("name.is.null"));
            throw new java.lang.NullPointerException(servlet40NLS.getString("name.is.null"));
        }

        return super.setInitParameter(name, value);
    }
557329
@Api
	public void setNamedRoles(Map<String, List<NamedRoleInfo>> namedRoles) {
		this.namedRoles = namedRoles;
		ldapRoleMapping = new HashMap<String, Set<String>>();
		for (String roleName : namedRoles.keySet()) {
			if (!ldapRoleMapping.containsKey(roleName)) {
				ldapRoleMapping.put(roleName, new HashSet<String>());
			}
			for (NamedRoleInfo role : namedRoles.get(roleName)) {
				ldapRoleMapping.get(roleName).add(role.getName());
			}
		}
	}
1060221
private AbstractSimon newSimon(String name, Class<? extends AbstractSimon> simonClass) {
		AbstractSimon simon = instantiateSimon(name, simonClass);
		if (name != null) {
			addToHierarchy(simon, name);
			SimonConfiguration config = configuration.getConfig(name);
			if (config.getState() != null) {
				simon.setState(config.getState(), false);
			}
			allSimons.put(name, simon);
		}
		return simon;
	}
522391
public void setParameters(String nameParam, String typeParam, String value) {
        this.parameters.put(nameParam, typeParam);
        this.parametersValue.add(value);
    }
1198599
public void setJobName(String name) throws IllegalStateException {
    ensureState(JobState.DEFINE);
    conf.setJobName(name);
  }
276699
@Override
    public void setName(String name) {

        m_textbox.setName(name);
        m_descriptionArea.setName(name + "_TextArea");

    }
28948
public void invokeVirtual(String methodName,
                              TypeDesc ret,
                              TypeDesc[] params) {
        invokeVirtual(mClassFile.getClassName(), methodName, ret, params);
    }
851608
void setBaseValues(CatalogMap<? extends CatalogType> parentMap, String name) {
        if (name == null) {
            throw new CatalogException("Null value where it shouldn't be.");
        }
        m_parentMap = parentMap;
        m_typename = name;
    }