Sets the order of this EnrollmentIdentities.

        :param order: The order of this EnrollmentIdentities.
        :type: str
185035
def order(self, order):
        
        if order is None:
            raise ValueError("Invalid value for `order`, must not be `None`")
        allowed_values = ["ASC", "DESC"]
        if order not in allowed_values:
            raise ValueError(
                "Invalid value for `order` ({0}), must be one of {1}"
                .format(order, allowed_values)
            )

        self._order = order
803604
def whatIfOrder(self, contract: Contract, order: Order) -> OrderState:
        
        return self._run(self.whatIfOrderAsync(contract, order))
439446
def add_order(self, order):
        
        # This key is used to group the orders based on region.
        key = '%s_%s' % (order.region_id, order.type_id)
        if not self._orders.has_key(key):
            # We don't have any orders for this yet. Prep the region+item
            # combo by instantiating a new MarketItemsInRegionList for
            # the MarketOrders.
            self.set_empty_region(
                order.region_id,
                order.type_id,
                order.generated_at
            )

        # The MarketOrder gets stuffed into the MarketItemsInRegionList for this
        # item+region combo.
        self._orders[key].add_order(order)
822606
@Override
    public void setOrder(Order order) {
        this.order = order;
        if (order != null) {
            switch (order) {
                case SINGLE:
                    this.electronCount = 2;
                    break;
                case DOUBLE:
                    this.electronCount = 4;
                    break;
                case TRIPLE:
                    this.electronCount = 6;
                    break;
                case QUADRUPLE:
                    this.electronCount = 8;
                    break;
                case QUINTUPLE:
                    this.electronCount = 10;
                    break;
                case SEXTUPLE:
                    this.electronCount = 12;
                    break;
                default:
                    this.electronCount = 0;
                    break;
            }
        }
    }
464910
protected function setOrderAccountOrder($order_id)
    {
        $this->data_order = $this->order->get($order_id);

        if (empty($this->data_order)) {
            $this->outputHttpStatus(404);
        }

        $this->prepareOrderAccountOrder($this->data_order);
    }
1206538
def placeOrder(self, contract, order, orderId=None, account=None):
        

        # get latest order id before submitting an order
        self.requestOrderIds()

        # continue...
        useOrderId = self.orderId if orderId == None else orderId
        if account:
            order.m_account = account
        self.ibConn.placeOrder(useOrderId, contract, order)

        account_key = order.m_account
        self.orders[useOrderId] = {
            "id":       useOrderId,
            "symbol":   self.contractString(contract),
            "contract": contract,
            "status":   "SENT",
            "reason":   None,
            "avgFillPrice": 0.,
            "parentId": 0,
            "time": datetime.fromtimestamp(int(self.time)),
            "account": None
        }
        if hasattr(order, "m_account"):
            self.orders[useOrderId]["account"] = order.m_account

        # return order id
        return useOrderId
592579
private function handleIdentity(OrderInterface $order)
    {
        if (null !== $user = $order->getUser()) {
            if (0 == strlen($order->getEmail())) {
                $order->setEmail($user->getEmail());
            }
            if (0 == strlen($order->getGender())) {
                $order->setGender($user->getGender());
            }
            if (0 == strlen($order->getFirstName())) {
                $order->setFirstName($user->getFirstName());
            }
            if (0 == strlen($order->getLastName())) {
                $order->setLastName($user->getLastName());
            }
        }
    }
702272
def p_opt_order(self, p):
        ''''''
        if len(p) > 1:
            if p[3] not in 'CF':
                raise PythranSyntaxError("Invalid Pythran spec. "
                                         "Unknown order '{}'".format(p[3]))
            p[0] = p[3]
        else:
            p[0] = None
1148044
public final function setOrderData(Order $order)
    {
        if (get_called_class() != self::class) {
            throw new \InvalidArgumentException("Method can be call only by OrderFinalized entity");
        }
        $this->id = $order->id;
        $this->setProperties($order);
    }
192508
def as_unordered(self, inplace=False):
        
        inplace = validate_bool_kwarg(inplace, 'inplace')
        return self.set_ordered(False, inplace=inplace)
1250855
public function order($order)
    {
        $order = $this->prepareNames(func_get_args(),false);
        $this->order = $order;
        return $this;
    }
657346
public function setOrder($order)
    {
        if (!empty($order)) {
            $this->query['order'] = $order;
        } else {
            unset($this->query['order']);
        }
        return $this;
    }
806479
def randomizeOrder(self):
        
        flag = [0] * len(self.inputs)
        self.loadOrder = [0] * len(self.inputs)
        for i in range(len(self.inputs)):
            pos = int(random.random() * len(self.inputs))
            while (flag[pos] == 1):
                pos = int(random.random() * len(self.inputs))
            flag[pos] = 1
            self.loadOrder[pos] = i
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);
        }
    }
1093049
def _set_arrayorder(obj, arrayorder='C'):
    
    msg = "Arg arrayorder must be in ['C','F']"
    assert arrayorder in ['C','F'], msg

    d = obj.to_dict(strip=-1)
    account = {'Success':[], 'Failed':[]}
    for k, v in d.items():
        if type(v) is np.array and v.ndim>1:
            try:
                if arrayorder=='C':
                    d[k] = np.ascontiguousarray(v)
                else:
                    d[k] = np.asfortranarray(v)
                account['Success'].append(k)
            except Exception as err:
                warnings.warn(str(err))
                account['Failed'].append(k)

    return d, account
1179422
public OQueryModel<K> setSort(String sortableParameter, SortOrder order)
    {
    	setSortableParameter(sortableParameter);
    	setAscending(SortOrder.ASCENDING.equals(order));
    	return this;
    }
267155
def assignOrderNames(self):
        
        try:
            schema = self.tableType().schema()
        except AttributeError:
            return
        
        for colname in self.columns():
            column = schema.column(colname)
            if column:
                self.setColumnOrderName(colname, column.name())