Setter.

@param pMethodCalls list of qualified method calls to cover
321244
public void setMethodCalls(final String... pMethodCalls)
    {
        final Set<String> newMethodCalls = new HashSet<>();
        Collections.addAll(newMethodCalls, pMethodCalls);
        methodCalls = Collections.unmodifiableSet(newMethodCalls);
    }
641824
public static Object applyMethod(Object pObject, String pMethod, Object ... pArgs) {
        Class<?> clazz = pObject.getClass();
        try {
            Method method = extractMethod(pMethod, clazz, pArgs);
            return method.invoke(pObject,pArgs);
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException("Cannot call method " + pMethod + " on " + pObject + ": " + e,e);
        } catch (InvocationTargetException e) {
            throw new IllegalArgumentException("Cannot call method " + pMethod + " on " + pObject + ": " + e,e);
        } catch (IllegalAccessException e) {
            throw new IllegalArgumentException("Cannot call method " + pMethod + " on " + pObject + ": " + e,e);
        }
    }
1124085
public void setPhoneNumbers(java.util.Collection<PhoneNumber> phoneNumbers) {
        if (phoneNumbers == null) {
            this.phoneNumbers = null;
            return;
        }

        this.phoneNumbers = new java.util.ArrayList<PhoneNumber>(phoneNumbers);
    }
266263
public void setParameters(Map<String, String> parameters) {

        if (m_parameters != null) {
            throw new IllegalStateException();
        }
        m_parameters = parameters;
    }
635610
public void setModel (PropertySheetModel pm)
  {
    if (pm instanceof org.apache.ojb.tools.mapping.reversedb.DBSchema)
    {
      this.aSchema = (org.apache.ojb.tools.mapping.reversedb.DBSchema)pm;
      this.readValuesFromSchema();
    }
    else
      throw new IllegalArgumentException();    
    
  }
1371084
def p_systemcall(self, p):
        ''
        p[0] = SystemCall(p[2], p[4], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
832862
public function setMethodCalls(array $calls = array())
    {
        $this->calls = array();
        foreach ($calls as $call) {
            $this->addMethodCall($call[0], $call[1]);
        }

        return $this;
    }
1094237
private void wrapSetterMethod(ClassNode classNode, boolean bindable, String propertyName) {
        String getterName = "get" + MetaClassHelper.capitalize(propertyName);
        MethodNode setter = classNode.getSetterMethod("set" + MetaClassHelper.capitalize(propertyName));

        if (setter != null) {
            // Get the existing code block
            Statement code = setter.getCode();

            Expression oldValue = varX("$oldValue");
            Expression newValue = varX("$newValue");
            Expression proposedValue = varX(setter.getParameters()[0].getName());
            BlockStatement block = new BlockStatement();

            // create a local variable to hold the old value from the getter
            block.addStatement(declS(oldValue, callThisX(getterName)));

            // add the fireVetoableChange method call
            block.addStatement(stmt(callThisX("fireVetoableChange", args(
                    constX(propertyName), oldValue, proposedValue))));

            // call the existing block, which will presumably set the value properly
            block.addStatement(code);

            if (bindable) {
                // get the new value to emit in the event
                block.addStatement(declS(newValue, callThisX(getterName)));

                // add the firePropertyChange method call
                block.addStatement(stmt(callThisX("firePropertyChange", args(constX(propertyName), oldValue, newValue))));
            }

            // replace the existing code block with our new one
            setter.setCode(block);
        }
    }
614942
private void setMappers(ObjectMapper mapper, XmlMapper xml) {
        synchronized (lock) {
            this.mapper = mapper;
            this.xml = xml;
            // mapper and xml are set to null on invalidation.
            if (mapper != null && xml != null) {
                applyMapperConfiguration(mapper, xml);
            }
        }
    }
554839
public void setForbidMethods(String[] forbidMethods) {
        for (String method : forbidMethods) {
            if (method.startsWith("*")) {
                if (forbidEndsMethods == null) {
                    forbidEndsMethods = new ArrayList<String>();
                }
                forbidEndsMethods.add(method.substring(1));
            } else if (method.endsWith("*")) {
                if (forbidStartsMethods == null) {
                    forbidStartsMethods = new ArrayList<String>();
                }
                forbidStartsMethods.add(method.substring(0, method.length() - 1));
            } else {
                if (forbidEqualsMethods == null) {
                    forbidEqualsMethods = new ArrayList<String>();
                }
                forbidEqualsMethods.add(method);
            }
        }
    }
1205513
private void updateMethodMap(Map<RequestMethod, List<Integer>> methodMap, Integer roleId, String methodMask) {
        for (int i = 0; i < RoleResourceConstant.METHOD_NUM; ++i) {
            if (methodMask.charAt(i) == RoleResourceConstant.METHOD_IS_ACCESSIBLE) {
                RequestMethod curMethod = RoleResourceConstant.IND_METHOD_MAP.get(i);

                // update List<roleId>
                List<Integer> roleIdList = methodMap.get(curMethod);
                if (roleIdList == null) {
                    roleIdList = new ArrayList<Integer>();
                    methodMap.put(curMethod, roleIdList);
                }
                roleIdList.add(roleId);
            }
        }
    }
651021
public void set(final MethodCallInfo another) {
		this.failed = another.failed;
		this.exception = another.exception;
		this.result = another.result;
	}
668913
public void setModel (PropertySheetModel pm)
  {
    if (pm instanceof org.apache.ojb.tools.mapping.reversedb.DBFKRelation)
    {
      this.aRelation = (org.apache.ojb.tools.mapping.reversedb.DBFKRelation)pm;
      this.readValuesFromReference();
    }
    else
      throw new IllegalArgumentException();    
  }
925746
function setProxy (call, property, data) {
    // reset call
    call = resetCall(call)
    // only allow set on data
    assert.ok(property === 'data', 'can only set value for data')
    // module name to set data for
    var moduleName
    // namespace context not set
    if (!defined(call.namespace)) {
        // get module name from session
        moduleName = getModuleName(call.session)
    }
    else if (defined(call.module)) {
        // cannot set data in method context
        assert.ok(!defined(call.method), 'ImmutableAI cannot set data in method context')
        // get full module name
        moduleName = call.module+GLOBAL.localNamespaces[call.namespace]
    }
    // require module name
    assert.ok(defined(moduleName), `ImmutableAI cannot set data without module context`)
    // set data
    GLOBAL.immutableCore.setData(moduleName, data)

    return true
}
1283404
@Override
    public void setMethod(String method) throws UnsupportedMethodException {
        MethodValues val = MethodValues.match(method, 0, method.length());
        if (null == val) {
            throw new UnsupportedMethodException("Illegal method " + method);
        }
        setMethod(val);
    }
399292
public SoapClient setMethod(QName name, Map<String, Object> params, boolean useMethodPrefix) {
		setMethod(name);
		final String prefix = name.getPrefix();
		final SOAPBodyElement methodEle = this.methodEle;
		for (Entry<String, Object> entry : MapUtil.wrap(params)) {
			setParam(methodEle, entry.getKey(), entry.getValue(), prefix);
		}

		return this;
	}
859792
protected boolean isSetterMethod(MethodDoc methodDoc) {
		if (methodDoc.parameters() != null && methodDoc.parameters().length == 1
				&& methodDoc.name().matches("^set.+")) {
			return true;
		}
		return false;
	}