<pre>
Use this operation to modify snmp alarm configuration.
</pre>
190843
public static snmp_alarm_config update(nitro_service client, snmp_alarm_config resource) throws Exception
	{
		resource.validate("modify");
		return ((snmp_alarm_config[]) resource.update_resource(client))[0];
	}
816981
public OperationFuture<Server> modifyPublicIp(Server server, ModifyPublicIpConfig config) {
        checkNotNull(config, CHECK_PUBLIC_IP_CONFIG);
        List<IpAddress> ipAddresses = findByRef(server).getDetails().getIpAddresses();

        List<String> responseIds = ipAddresses.stream()
            .map(IpAddress::getPublicIp)
            .filter(notNull())
            .map(ipAddress ->
                client.modifyPublicIp(idByRef(server),
                    ipAddress,
                    publicIpConverter.createPublicIpRequest(config)))
            .map(Link::getId)
            .collect(toList());

        return new OperationFuture<>(
            server,
            responseIds,
            queueClient
        );
    }
43618
@Override
	public void reconfigure() {

		// Update the messaging client
		this.logger.info( "Reconfiguration requested in the DM." );
		if( this.messagingClient != null ) {
			this.messagingClient.setDomain( this.domain );
			this.messagingClient.switchMessagingType( this.messagingType );
			try {
				if( this.messagingClient.isConnected())
					this.messagingClient.listenToTheDm( ListenerCommand.START );

			} catch ( IOException e ) {
				this.logger.log( Level.WARNING, "Cannot start to listen to the debug queue", e );
			}
		}

		// We must update instance states after we switched the messaging configuration.
		restoreAllInstances();

		this.logger.info( "The DM was successfully (re)configured." );
	}
88712
public OperationFuture<List<Server>> modify(ServerFilter serverFilter, ModifyServerConfig modifyServerConfig) {
        List<Server> serverList = find(serverFilter)
            .stream()
            .map(ServerMetadata::asRefById)
            .collect(toList());

        return modify(serverList, modifyServerConfig);
    }
80789
public static snmp_view add(nitro_service client, snmp_view resource) throws Exception
	{
		resource.validate("add");
		return ((snmp_view[]) resource.perform_operation(client, "add"))[0];
	}
563254
private void scheduleAlarm(long timeOut)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "scheduleAlarm timeOut=" + timeOut);
        
        // NB PM27294 implementation now means you cannot decrease the the timeOut if an alarm is already scheduled.
        // This is OK for the expirer as the timeout does not change once Expirer is started.
        synchronized (lockObject)
        {
            // if there is not an alarm already scheduled and there exists no thread that will go on to call scheduleAlarm then
            // create an alarm.
            if (! alarmScheduled && ! alarming)
            {
                expiryAlarm = AlarmManager.createNonDeferrable(timeOut, this);
                alarmScheduled = true;
            }
        }
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "scheduleAlarm", alarmScheduled);
    }
669827
public static sdx_network_config update(nitro_service client, sdx_network_config resource) throws Exception
	{
		resource.validate("modify");
		return ((sdx_network_config[]) resource.update_resource(client))[0];
	}
860316
public void setOperatingSystemTargeting(com.google.api.ads.admanager.axis.v201811.OperatingSystemTargeting operatingSystemTargeting) {
        this.operatingSystemTargeting = operatingSystemTargeting;
    }
881314
private void applyConnectionManagerConfiguration(ConnectionManagerConfiguration cmc,
      org.ironjacamar.common.api.metadata.common.Security s)
   {
      if (s != null && s.getSecurityDomain() != null)
      {
         cmc.setSecurityDomain(s.getSecurityDomain());
      }
   }
628596
public static br_snmpmanager[] addmanager(nitro_service client, br_snmpmanager[] resources) throws Exception
	{
		if(resources == null)
			throw new Exception("Null resource array");
		
		
		if(resources.length == 1)
			return ((br_snmpmanager[]) resources[0].perform_operation(client, "addmanager"));
		
		return ((br_snmpmanager[]) perform_operation_bulk_request(client, resources, "addmanager"));
	}
280037
def modify(self, **patch):
        """"""
        if 'monitor' in patch:
            value = self._format_monitor_parameter(patch['monitor'])
            patch['monitor'] = value
        return super(Pool, self)._modify(**patch)
1260733
@Process(actionType = ModifyEndpointConfiguration.class)
    public void modifyEndpointConfiguration(final ModifyEndpointConfiguration action, final Dispatcher.Channel channel) {
        operationDelegate.onSaveResource(ENDPOINT_CONFIGURATION_ADDRESS, null, action.getChangedValues(),
                new CrudOperationDelegate.Callback() {
                    @Override
                    public void onSuccess(final AddressTemplate addressTemplate, final String name) {
                        final ModelNode op = readEndpointConfiguration();
                        dispatcher.execute(new DMRAction(op), new AsyncCallback<DMRResponse>() {
                            @Override
                            public void onFailure(Throwable caught) {
                                channel.nack(caught);
                            }

                            @Override
                            public void onSuccess(DMRResponse dmrResponse) {
                                ModelNode response = dmrResponse.get();
                                if (response.isFailure()) {
                                    channel.nack(new RuntimeException("Failed to read " + addressTemplate + " using " + op + ": " +
                                            response.getFailureDescription()));
                                } else {
                                    endpointConfiguration = response.get(RESULT);
                                    channel.ack();
                                }
                            }
                        });
                    }

                    @Override
                    public void onFailure(AddressTemplate addressTemplate, String name, Throwable t) {
                        channel.nack(t);
                    }
                });
    }
238510
public static current_hostname modify(nitro_service client, current_hostname resource) throws Exception
	{
		resource.validate("modify");
		return ((current_hostname[]) resource.update_resource(client))[0];
	}
19586
private static void setServiceEnabled(final XMPPConnection connection,
            final boolean isEnabled) {
        ServiceDiscoveryManager manager = ServiceDiscoveryManager
                .getInstanceFor(connection);

        List<String> namespaces = new ArrayList<>();
        namespaces.addAll(Arrays.asList(NAMESPACE));
        namespaces.add(DataPacketExtension.NAMESPACE);
        if (!IBB_ONLY) {
            namespaces.add(Bytestream.NAMESPACE);
        }

        for (String namespace : namespaces) {
            if (isEnabled) {
                manager.addFeature(namespace);
            } else {
                manager.removeFeature(namespace);
            }
        }
    }
230064
public static ns_vserver_appflow_config modify(nitro_service client, ns_vserver_appflow_config resource) throws Exception
	{
		resource.validate("modify");
		return ((ns_vserver_appflow_config[]) resource.update_resource(client))[0];
	}
244978
public void configure(@NonNull VoidConfiguration configuration, @NonNull Transport transport, @NonNull UpdaterParametersProvider updaterProvider) {
        this.transport = transport;
        this.masterMode = false;
        this.configuration = configuration;
        this.updaterParametersProvider = updaterProvider;
    }
1105505
public static base_responses update(nitro_service client, snmpmanager resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			snmpmanager updateresources[] = new snmpmanager[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new snmpmanager();
				updateresources[i].ipaddress = resources[i].ipaddress;
				updateresources[i].netmask = resources[i].netmask;
				updateresources[i].domainresolveretry = resources[i].domainresolveretry;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}