Sets the boot order for this virtual machine. This method should
 never be called directly. Instead, modify the `boot_order` array.
773401
def set_boot_order(interface, key, value)
      max_boot = Global.global.system_properties.max_boot_position
      value = value.dup
      value.concat(Array.new(max_boot - value.size)) if value.size < max_boot

      (1..max_boot).each do |position|
        interface.set_boot_order(position, value[position - 1])
      end
    end
667380
def set_vm_status(self, boot_on_next_reset):
        
        data = {
            "Oem": {
                "Hpe": {
                    "BootOnNextServerReset": boot_on_next_reset
                    }
                }
            }
        self._conn.patch(self.path, data=data)
588146
def save
      return false unless valid?
      raise Exceptions::ReadonlyVMStateException.new("VM must not be in saved state to modify.") if saved?

      with_open_session do |session|
        # Use setters to save the attributes on the locked machine and persist
        # the settings
        machine = session.machine

        # Save the boot order
        save_interface_attribute(:boot_order, machine)

        # Save all the attributes and relationships
        save_changed_interface_attributes(machine)

        # Save relationships, which may open their own sessions if necessary
        save_relationships
      end

      true
    end
475942
public void setOrderedPhoneNumbers(java.util.Collection<OrderedPhoneNumber> orderedPhoneNumbers) {
        if (orderedPhoneNumbers == null) {
            this.orderedPhoneNumbers = null;
            return;
        }

        this.orderedPhoneNumbers = new java.util.ArrayList<OrderedPhoneNumber>(orderedPhoneNumbers);
    }
1188397
public function boot()
    {
        if ($this->booted) {
            return;
        }

        \array_walk($this->loadedProviders, function ($p) {
            $this->bootProvider($p);
        });

        // Once the application has booted we will also fire some "booted" callbacks
        // for any listeners that need to do work after this initial booting gets
        // finished. This is useful when ordering the boot-up processes we run.
        $this->fireAppCallbacks($this->bootingCallbacks);

        $this->booted = true;

        $this->fireAppCallbacks($this->bootedCallbacks);
    }
689514
protected function setSort()
    {
        $this->sort = Input::get($this->sortName, []);
        if (!is_array($this->sort)) {
            return;
        }

        if (empty($this->sort['column']) || empty($this->sort['type'])) {
            return;
        }

        if (Str::contains($this->sort['column'], '.')) {
            $this->setRelationSort($this->sort['column']);
        } else {
            $this->resetOrderBy();

            // get column. if contains "cast", set set column as cast
            if (!empty($this->sort['cast'])) {
                $column = "CAST({$this->sort['column']} AS {$this->sort['cast']}) {$this->sort['type']}";
                $method = 'orderByRaw';
                $arguments = [$column];
            } else {
                $column = $this->sort['column'];
                $method = 'orderBy';
                $arguments = [$column, $this->sort['type']];
            }

            $this->queries->push([
                'method'    => $method,
                'arguments' => $arguments,
            ]);
        }
    }
668065
function set_sort_order($sort_col, $sort_order = null)
    {
        if ($this->coltypes[$sort_col]['attributes'])
            $this->sort_col = $this->coltypes[$sort_col]['attributes'][0];
    }
1227769
protected function setSort()
    {
        $this->sort = Input::get($this->sortName, []);
        if (!is_array($this->sort)) {
            return;
        }

        if (empty($this->sort['column']) || empty($this->sort['type'])) {
            return;
        }

        if (str_contains($this->sort['column'], '.')) {
            $this->setRelationSort($this->sort['column']);
        } else {
            $this->resetOrderBy();

            $this->queries->push([
                'method' => 'orderBy',
                'arguments' => [$this->sort['column'], $this->sort['type']],
            ]);
        }
    }
1060770
public void setOrdering(String ordering) {

        if (ordering != null) {
            m_ordering = new CmsSimpleQueryFragment(ordering, Collections.<Object> emptyList());
        } else {
            m_ordering = null;
        }
    }
252319
protected function setSourceOrder()
    {
        $this->source = Mage::getModel('sales/order');
        $this->source->load($this->id);
    }
1357579
public void setKeyOrder(boolean bKeyOrder)
    {
        super.setKeyOrder(bKeyOrder);
        boolean bForceUniqueKey = true;
        int iKeyFieldCount = this.getKeyFields(bForceUniqueKey, false);
        for (int iKeyFieldSeq = DBConstants.MAIN_KEY_FIELD; iKeyFieldSeq < iKeyFieldCount; iKeyFieldSeq++)
        {
            KeyField keyField = this.getKeyField(iKeyFieldSeq, bForceUniqueKey);
            keyField.setKeyOrder(bKeyOrder);
        }
    }
21004
private boolean placeOrderOrderOnAPI(final BitfinexNewOrder order) throws Exception {
		final CountDownLatch waitLatch = new CountDownLatch(1);

		final Consumer<BitfinexSubmittedOrder> ordercallback = (o) -> {
			if(Objects.equals(o.getClientId(), order.getClientId())) {
				waitLatch.countDown();
			}
		}
825580
def set_sort_order(self, sort_order):
        

        if not isinstance(sort_order, SortOrder):
            raise DaftException("sort_order should be an instance of SortOrder.")

        self._sort_order = str(sort_order)
227460
public function bootIfNotBooted()
    {
        if (
            isset($this->defaultValues)
            || is_array($this->defaultValues)
            || !empty($this->defaultValues)
        ) {
            $attributes = array_replace_recursive($this->defaultValues, $this->attributes);

            $this->fill($attributes);
        }

        parent::bootIfNotBooted();
    }
632139
def _setup_last_ordered_for_non_master(self):
        
        if not self.isMaster and self.first_batch_after_catchup and \
                not self.isPrimary:
            # If not master instance choose last ordered seq no to be 1 less
            # the lowest prepared certificate in this view
            lowest_prepared = self.get_lowest_probable_prepared_certificate_in_view(
                self.viewNo)
            if lowest_prepared is not None:
                # now after catch up we have in last_ordered_3pc[1] value 0
                # it value should change last_ordered_3pc to lowest_prepared - 1
                self.logger.info('{} Setting last ordered for non-master as {}'.
                                 format(self, self.last_ordered_3pc))
                self.last_ordered_3pc = (self.viewNo, lowest_prepared - 1)
                self.update_watermark_from_3pc()
                self.first_batch_after_catchup = False
554926
protected function bootCommand()
    {
        foreach ($this->commands as $command) {
            $this->add($this->app->make($command));
        }
    }
644657
public void setPreferredOrder(final Collection<Class<? extends Saga>> preferredOrder) {
        checkNotNull(preferredOrder, "Preferred order list may not be null. Empty is allowed.");

        cacheLoader.setPreferredOrder(preferredOrder);
        sagasForMessageType.invalidateAll();
    }