Use this API to update nstcpparam.
180702
public static base_response update(nitro_service client, nstcpparam resource) throws Exception {
		nstcpparam updateresource = new nstcpparam();
		updateresource.ws = resource.ws;
		updateresource.wsval = resource.wsval;
		updateresource.sack = resource.sack;
		updateresource.learnvsvrmss = resource.learnvsvrmss;
		updateresource.maxburst = resource.maxburst;
		updateresource.initialcwnd = resource.initialcwnd;
		updateresource.recvbuffsize = resource.recvbuffsize;
		updateresource.delayedack = resource.delayedack;
		updateresource.downstaterst = resource.downstaterst;
		updateresource.nagle = resource.nagle;
		updateresource.limitedpersist = resource.limitedpersist;
		updateresource.oooqsize = resource.oooqsize;
		updateresource.ackonpush = resource.ackonpush;
		updateresource.maxpktpermss = resource.maxpktpermss;
		updateresource.pktperretx = resource.pktperretx;
		updateresource.minrto = resource.minrto;
		updateresource.slowstartincr = resource.slowstartincr;
		updateresource.maxdynserverprobes = resource.maxdynserverprobes;
		updateresource.synholdfastgiveup = resource.synholdfastgiveup;
		updateresource.maxsynholdperprobe = resource.maxsynholdperprobe;
		updateresource.maxsynhold = resource.maxsynhold;
		updateresource.msslearninterval = resource.msslearninterval;
		updateresource.msslearndelay = resource.msslearndelay;
		updateresource.maxtimewaitconn = resource.maxtimewaitconn;
		updateresource.kaprobeupdatelastactivity = resource.kaprobeupdatelastactivity;
		updateresource.maxsynackretx = resource.maxsynackretx;
		updateresource.synattackdetection = resource.synattackdetection;
		updateresource.connflushifnomem = resource.connflushifnomem;
		updateresource.connflushthres = resource.connflushthres;
		updateresource.mptcpconcloseonpassivesf = resource.mptcpconcloseonpassivesf;
		updateresource.mptcpchecksum = resource.mptcpchecksum;
		updateresource.mptcpsftimeout = resource.mptcpsftimeout;
		updateresource.mptcpsfreplacetimeout = resource.mptcpsfreplacetimeout;
		updateresource.mptcpmaxsf = resource.mptcpmaxsf;
		updateresource.mptcpmaxpendingsf = resource.mptcpmaxpendingsf;
		updateresource.mptcppendingjointhreshold = resource.mptcppendingjointhreshold;
		updateresource.mptcprtostoswitchsf = resource.mptcprtostoswitchsf;
		updateresource.mptcpusebackupondss = resource.mptcpusebackupondss;
		updateresource.tcpmaxretries = resource.tcpmaxretries;
		updateresource.mptcpimmediatesfcloseonfin = resource.mptcpimmediatesfcloseonfin;
		return updateresource.update_resource(client);
	}
664678
def update(self) -> None:
        """"""
        mask = self.mask
        weights = self.refweights[mask]
        self[~mask] = numpy.nan
        self[mask] = weights/numpy.sum(weights)
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);
	}
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);
	}
321550
public static base_response update(nitro_service client, nsacl resource) throws Exception {
		nsacl updateresource = new nsacl();
		updateresource.aclname = resource.aclname;
		updateresource.aclaction = resource.aclaction;
		updateresource.srcip = resource.srcip;
		updateresource.srcipop = resource.srcipop;
		updateresource.srcipval = resource.srcipval;
		updateresource.srcport = resource.srcport;
		updateresource.srcportop = resource.srcportop;
		updateresource.srcportval = resource.srcportval;
		updateresource.destip = resource.destip;
		updateresource.destipop = resource.destipop;
		updateresource.destipval = resource.destipval;
		updateresource.destport = resource.destport;
		updateresource.destportop = resource.destportop;
		updateresource.destportval = resource.destportval;
		updateresource.srcmac = resource.srcmac;
		updateresource.protocol = resource.protocol;
		updateresource.protocolnumber = resource.protocolnumber;
		updateresource.icmptype = resource.icmptype;
		updateresource.icmpcode = resource.icmpcode;
		updateresource.vlan = resource.vlan;
		updateresource.Interface = resource.Interface;
		updateresource.priority = resource.priority;
		updateresource.logstate = resource.logstate;
		updateresource.ratelimit = resource.ratelimit;
		updateresource.established = resource.established;
		return updateresource.update_resource(client);
	}
835622
public static base_response update(nitro_service client, vpathparam resource) throws Exception {
		vpathparam updateresource = new vpathparam();
		updateresource.srcip = resource.srcip;
		return updateresource.update_resource(client);
	}
461628
public static base_responses update(nitro_service client, nstcpprofile resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			nstcpprofile updateresources[] = new nstcpprofile[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new nstcpprofile();
				updateresources[i].name = resources[i].name;
				updateresources[i].ws = resources[i].ws;
				updateresources[i].sack = resources[i].sack;
				updateresources[i].wsval = resources[i].wsval;
				updateresources[i].nagle = resources[i].nagle;
				updateresources[i].ackonpush = resources[i].ackonpush;
				updateresources[i].mss = resources[i].mss;
				updateresources[i].maxburst = resources[i].maxburst;
				updateresources[i].initialcwnd = resources[i].initialcwnd;
				updateresources[i].delayedack = resources[i].delayedack;
				updateresources[i].oooqsize = resources[i].oooqsize;
				updateresources[i].maxpktpermss = resources[i].maxpktpermss;
				updateresources[i].pktperretx = resources[i].pktperretx;
				updateresources[i].minrto = resources[i].minrto;
				updateresources[i].slowstartincr = resources[i].slowstartincr;
				updateresources[i].buffersize = resources[i].buffersize;
				updateresources[i].syncookie = resources[i].syncookie;
				updateresources[i].kaprobeupdatelastactivity = resources[i].kaprobeupdatelastactivity;
				updateresources[i].flavor = resources[i].flavor;
				updateresources[i].dynamicreceivebuffering = resources[i].dynamicreceivebuffering;
				updateresources[i].ka = resources[i].ka;
				updateresources[i].kaconnidletime = resources[i].kaconnidletime;
				updateresources[i].kamaxprobes = resources[i].kamaxprobes;
				updateresources[i].kaprobeinterval = resources[i].kaprobeinterval;
				updateresources[i].sendbuffsize = resources[i].sendbuffsize;
				updateresources[i].mptcp = resources[i].mptcp;
				updateresources[i].establishclientconn = resources[i].establishclientconn;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1054473
public static base_response update(nitro_service client, route resource) throws Exception {
		route updateresource = new route();
		updateresource.network = resource.network;
		updateresource.netmask = resource.netmask;
		updateresource.gateway = resource.gateway;
		updateresource.td = resource.td;
		updateresource.distance = resource.distance;
		updateresource.cost1 = resource.cost1;
		updateresource.weight = resource.weight;
		updateresource.advertise = resource.advertise;
		updateresource.protocol = resource.protocol;
		updateresource.msr = resource.msr;
		updateresource.monitor = resource.monitor;
		return updateresource.update_resource(client);
	}
188657
public static base_response update(nitro_service client, snmpalarm resource) throws Exception {
		snmpalarm updateresource = new snmpalarm();
		updateresource.trapname = resource.trapname;
		updateresource.thresholdvalue = resource.thresholdvalue;
		updateresource.normalvalue = resource.normalvalue;
		updateresource.time = resource.time;
		updateresource.state = resource.state;
		updateresource.severity = resource.severity;
		updateresource.logging = resource.logging;
		return updateresource.update_resource(client);
	}
1236659
protected void updatePacketListener() {
        removeAsyncPacketListener();

        LOGGER.fine("UpdatePacketListener");

        packetListener = new StanzaListener() {
            @Override
            public void processStanza(Stanza packet) {
                try {
                    receivePacketAndRespond((IQ) packet);
                } catch (Exception e) {
                    LOGGER.log(Level.WARNING, "exception", e);
                }
            }
        };

        packetFilter = new StanzaFilter() {
            @Override
            public boolean accept(Stanza packet) {

                if (packet instanceof IQ) {
                    IQ iq = (IQ) packet;

                    Jid me = getConnection().getUser();

                    if (!iq.getTo().equals(me)) {
                        return false;
                    }

                    Jid other = getResponder().equals(me) ? getInitiator() : getResponder();

                    if (iq.getFrom() == null || !iq.getFrom().equals(other == null ? "" : other)) {
                        return false;
                    }

                    if (iq instanceof Jingle) {
                        Jingle jin = (Jingle) iq;

                        String sid = jin.getSid();
                        if (sid == null || !sid.equals(getSid())) {
                            LOGGER.fine("Ignored Jingle(SID) " + sid + "|" + getSid() + " :" + iq.toXML());
                            return false;
                        }
                        Jid ini = jin.getInitiator();
                        if (!ini.equals(getInitiator())) {
                            LOGGER.fine("Ignored Jingle(INI): " + iq.toXML());
                            return false;
                        }
                    } else {
                        // We accept some non-Jingle IQ packets: ERRORs and ACKs
                        if (iq.getType().equals(IQ.Type.set)) {
                            LOGGER.fine("Ignored Jingle(TYPE): " + iq.toXML());
                            return false;
                        } else if (iq.getType().equals(IQ.Type.get)) {
                            LOGGER.fine("Ignored Jingle(TYPE): " + iq.toXML());
                            return false;
                        }
                    }
                    return true;
                }
                return false;
            }
        };

        getConnection().addAsyncStanzaListener(packetListener, packetFilter);
    }
1057565
public static base_response update(nitro_service client, ntpserver resource) throws Exception {
		ntpserver updateresource = new ntpserver();
		updateresource.serverip = resource.serverip;
		updateresource.servername = resource.servername;
		updateresource.minpoll = resource.minpoll;
		updateresource.maxpoll = resource.maxpoll;
		updateresource.preferredntpserver = resource.preferredntpserver;
		updateresource.autokey = resource.autokey;
		updateresource.key = resource.key;
		return updateresource.update_resource(client);
	}
989311
public static base_response update(nitro_service client, nshostname resource) throws Exception {
		nshostname updateresource = new nshostname();
		updateresource.hostname = resource.hostname;
		updateresource.ownernode = resource.ownernode;
		return updateresource.update_resource(client);
	}
678540
public static base_responses update(nitro_service client, snmpuser resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			snmpuser updateresources[] = new snmpuser[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new snmpuser();
				updateresources[i].name = resources[i].name;
				updateresources[i].group = resources[i].group;
				updateresources[i].authtype = resources[i].authtype;
				updateresources[i].authpasswd = resources[i].authpasswd;
				updateresources[i].privtype = resources[i].privtype;
				updateresources[i].privpasswd = resources[i].privpasswd;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
808455
public static base_responses update(nitro_service client, snmptrap resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			snmptrap updateresources[] = new snmptrap[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new snmptrap();
				updateresources[i].trapclass = resources[i].trapclass;
				updateresources[i].trapdestination = resources[i].trapdestination;
				updateresources[i].destport = resources[i].destport;
				updateresources[i].version = resources[i].version;
				updateresources[i].communityname = resources[i].communityname;
				updateresources[i].srcip = resources[i].srcip;
				updateresources[i].severity = resources[i].severity;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
56227
public static base_response update(nitro_service client, ptp resource) throws Exception {
		ptp updateresource = new ptp();
		updateresource.state = resource.state;
		return updateresource.update_resource(client);
	}
516018
public static base_response update(nitro_service client, snmpmib resource) throws Exception {
		snmpmib updateresource = new snmpmib();
		updateresource.contact = resource.contact;
		updateresource.name = resource.name;
		updateresource.location = resource.location;
		updateresource.customid = resource.customid;
		return updateresource.update_resource(client);
	}
994335
public void update() {
        final long time = System.currentTimeMillis();
        elapsedTime += time - lastUpdateTime;
        lastUpdateTime = time;
        frameCount++;
        if (elapsedTime >= 1000) {
            tps = frameCount;
            frameCount = 0;
            elapsedTime = 0;
        }
    }