Use this API to update nsweblogparam.
170118
public static base_response update(nitro_service client, nsweblogparam resource) throws Exception {
		nsweblogparam updateresource = new nsweblogparam();
		updateresource.buffersizemb = resource.buffersizemb;
		updateresource.customreqhdrs = resource.customreqhdrs;
		updateresource.customrsphdrs = resource.customrsphdrs;
		return updateresource.update_resource(client);
	}
272919
public static base_response update(nitro_service client, snmpoption resource) throws Exception {
		snmpoption updateresource = new snmpoption();
		updateresource.snmpset = resource.snmpset;
		updateresource.snmptraplogging = resource.snmptraplogging;
		return updateresource.update_resource(client);
	}
536513
public static base_response update(nitro_service client, nsparam resource) throws Exception {
		nsparam updateresource = new nsparam();
		updateresource.httpport = resource.httpport;
		updateresource.maxconn = resource.maxconn;
		updateresource.maxreq = resource.maxreq;
		updateresource.cip = resource.cip;
		updateresource.cipheader = resource.cipheader;
		updateresource.cookieversion = resource.cookieversion;
		updateresource.securecookie = resource.securecookie;
		updateresource.pmtumin = resource.pmtumin;
		updateresource.pmtutimeout = resource.pmtutimeout;
		updateresource.ftpportrange = resource.ftpportrange;
		updateresource.crportrange = resource.crportrange;
		updateresource.timezone = resource.timezone;
		updateresource.grantquotamaxclient = resource.grantquotamaxclient;
		updateresource.exclusivequotamaxclient = resource.exclusivequotamaxclient;
		updateresource.grantquotaspillover = resource.grantquotaspillover;
		updateresource.exclusivequotaspillover = resource.exclusivequotaspillover;
		updateresource.useproxyport = resource.useproxyport;
		updateresource.internaluserlogin = resource.internaluserlogin;
		updateresource.aftpallowrandomsourceport = resource.aftpallowrandomsourceport;
		updateresource.icaports = resource.icaports;
		return updateresource.update_resource(client);
	}
867178
public static base_response update(nitro_service client, ipsecparameter resource) throws Exception {
		ipsecparameter updateresource = new ipsecparameter();
		updateresource.ikeversion = resource.ikeversion;
		updateresource.encalgo = resource.encalgo;
		updateresource.hashalgo = resource.hashalgo;
		updateresource.lifetime = resource.lifetime;
		updateresource.livenesscheckinterval = resource.livenesscheckinterval;
		updateresource.replaywindowsize = resource.replaywindowsize;
		updateresource.ikeretryinterval = resource.ikeretryinterval;
		updateresource.retransmissiontime = resource.retransmissiontime;
		return updateresource.update_resource(client);
	}
72328
public static base_response update(nitro_service client, locationparameter resource) throws Exception {
		locationparameter updateresource = new locationparameter();
		updateresource.context = resource.context;
		updateresource.q1label = resource.q1label;
		updateresource.q2label = resource.q2label;
		updateresource.q3label = resource.q3label;
		updateresource.q4label = resource.q4label;
		updateresource.q5label = resource.q5label;
		updateresource.q6label = resource.q6label;
		return updateresource.update_resource(client);
	}
705777
def update(self, *, name=None, position=None, visibility=None):
        

        if name is None and position is None and visibility is None:
            raise ValueError('Provide at least one parameter to update')
        data = {}
        if name:
            data['name'] = name
        if position:
            data['position'] = position
        if visibility:
            data['visibility'] = visibility

        response = self.session.patch(self.build_url(''), data=data)
        if not response:
            return False

        data = response.json()
        self.name = data.get('name', self.name)
        self.position = data.get('position', self.position)
        self.visibility = data.get('visibility', self.visibility)

        return True
805135
def update(self, data, key):
        """"""
        og_data = self.read()
        og_data[key] = data
        self.write(og_data)
591340
public synchronized void updateFromTrackParameters(TrackParameters track) {
    parameters.clear();
    for(TrackedParameter p : track.getAllParameters()) {
      Parameter<?> option = p.getParameter();
      String value = null;
      if(option.isDefined()) {
        if(option.tookDefaultValue()) {
          value = DynamicParameters.STRING_USE_DEFAULT + option.getDefaultValueAsString();
        }
        else {
          value = option.getValueAsString();
        }
      }
      if(value == null) {
        value = (option instanceof Flag) ? Flag.NOT_SET : "";
      }
      int bits = 0;
      if(option.isOptional()) {
        bits |= BIT_OPTIONAL;
      }
      if(option.hasDefaultValue() && option.tookDefaultValue()) {
        bits |= BIT_DEFAULT_VALUE;
      }
      if(value.length() <= 0) {
        if((bits & BIT_DEFAULT_VALUE) == 0 && (bits & BIT_OPTIONAL) == 0) {
          bits |= BIT_INCOMPLETE;
        }
      }
      else {
        try {
          if(!option.tookDefaultValue() && !option.isValid(value)) {
            bits |= BIT_INVALID;
          }
        }
        catch(ParameterException e) {
          bits |= BIT_INVALID;
        }
      }
      int depth = 0;
      {
        Object pos = track.getParent(option);
        while(pos != null) {
          pos = track.getParent(pos);
          depth += 1;
          if(depth > 10) {
            break;
          }
        }
      }
      parameters.add(new Node(option, value, bits, depth));
    }
  }
1340648
protected void updateParameterTable() {
    parameterTable.setEnabled(false);
    ListParameterization config = new ListParameterization();
    parameterTable.appendParameters(config);
    setParameters(config);
    if(config.getErrors().size() > 0) {
      reportErrors(config);
    }
    config.clearErrors();
    parameterTable.setEnabled(true);
  }
837796
def update(self, **kwargs):
        
        for arg in kwargs:
            if hasattr(self, arg):
                setattr(self, arg, kwargs[arg])
            else:
                raise ValueError("Invalid RayParams parameter in"
                                 " update: %s" % arg)

        self._check_usage()
155945
def updateParams(self, newvalues, update_all=False):
        """"""
        assert all(map(lambda x: x in self.freeparams, newvalues.keys())),\
                "Invalid entry in newvalues: {0}\nfreeparams: {1}".format(
                ', '.join(newvalues.keys()), ', '.join(self.freeparams))
        changed = set([]) # contains string names of changed params
        for (name, value) in newvalues.items():
            _checkParam(name, value, self.PARAMLIMITS, self.PARAMTYPES)
            if isinstance(value, scipy.ndarray):
                if (value != getattr(self, name)).any():
                    changed.add(name)
                    setattr(self, name, value.copy())
            else:
                if value != getattr(self, name):
                    changed.add(name)
                    setattr(self, name, copy.copy(value))

        if update_all or changed:
            self._cached = {}

        # The order of the updating below is important.
        # If you change it, you may break either this class
        # **or** classes that inherit from it.
        # Note also that not all attributes need to be updated
        # for all possible parameter changes, but just doing it
        # this way is much simpler and adds negligible cost.
        if update_all or (changed and changed != set(['mu'])):
            self._update_pi_vars()
            self._update_phi()
            self._update_prx()
            self._update_dprx()
            self._update_Qxy()
            self._update_Frxy()
            self._update_Prxy()
            self._update_Prxy_diag()
            self._update_dPrxy()
            self._update_B()
986633
public static ns update(nitro_service client, ns resource) throws Exception
	{
		resource.validate("modify");
		return ((ns[]) resource.update_resource(client))[0];
	}
38815
def _update_param(self):
        

        """

        # Update relaxation parameter.
        if not isinstance(self._rho_update, type(None)):
            self._rho = self._rho_update(self._rho)

        # Update proximal dual parameter.
        if not isinstance(self._sigma_update, type(None)):
            self._sigma = self._sigma_update(self._sigma)

        # Update proximal primal parameter.
        if not isinstance(self._tau_update, type(None)):
            self._tau = self._tau_update(self._tau)
687774
public static base_response update(nitro_service client, nsdhcpparams resource) throws Exception {
		nsdhcpparams updateresource = new nsdhcpparams();
		updateresource.dhcpclient = resource.dhcpclient;
		updateresource.saveroute = resource.saveroute;
		return updateresource.update_resource(client);
	}
576714
def update(self, params, path, **kwargs):
        
        self.client.request('POST', params, path, **kwargs)
967512
def update(self, **kwargs):
        """"""
        self._check_exclusive_parameters(**kwargs)
        return super(Rule, self)._update(**kwargs)
694237
public static base_response update(nitro_service client, nstcpbufparam resource) throws Exception {
		nstcpbufparam updateresource = new nstcpbufparam();
		updateresource.size = resource.size;
		updateresource.memlimit = resource.memlimit;
		return updateresource.update_resource(client);
	}