@param int $byteOrder The byte order, one of the WKBTools::BIG_ENDIAN or WKBTools::LITTLE_ENDIAN constants.

@return void

@throws \InvalidArgumentException If the byte order is invalid.
971032
public function setByteOrder(int $byteOrder) : void
    {
        WKBTools::checkByteOrder($byteOrder);
        $this->byteOrder = $byteOrder;
    }
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();
			}
		}
592668
public function setIsUnaryOperator($isUnaryOperator = true)
    {
        if (! is_a($this->getSymbol(), AbstractOperator::class)) {
            throw new \InvalidArgumentException(
                'Error: Cannot mark node as unary operator, because symbol is not an operator but of type "'.
                gettype($this->getSymbol()).'"'
            );
        }

        $this->isUnaryOperator = $isUnaryOperator;
    }
1286724
public function setLogger($logger) {
		if(!in_array('Psr\Log\LoggerInterface', class_implements($logger, true))) {
			throw new \InvalidArgumentException('Logger object does not implement Psr\Log\LoggerInterface');
		}
		$this->logger = $logger;
	}
245958
public function setPager($pager)
    {
        if ($pager && !\is_string($pager) && !$pager instanceof OutputPager) {
            throw new \InvalidArgumentException('Unexpected pager instance');
        }

        $this->pager = $pager;
    }
395671
def byte_order_option(default=BYTEORDER):
    

    def decorator(method):
        @wraps(method)
        def wrapper(*args, **kwargs):
            option = Option.byte_order.value
            kwargs[option] = kwargs.get(option, default)
            return method(*args, **kwargs)

        return wrapper

    return decorator
364247
public function readByteOrder() : void
    {
        $byteOrder = $this->readUnsignedChar();

        if ($byteOrder !== WKBTools::BIG_ENDIAN && $byteOrder !== WKBTools::LITTLE_ENDIAN) {
            throw GeometryIOException::invalidWKB('unknown byte order: ' . $byteOrder);
        }

        $this->invert = ($byteOrder !== $this->machineByteOrder);
    }
715259
public function setOrderParameters($idAttr, $orderAttr, $labelAttr)
    {
        $this->orderParameters = [
            'idAttr' => $idAttr,
            'orderAttr' => $orderAttr,
            'labelAttr' => $labelAttr
        ];

        return $this;
    }
563991
public function updateBlockTypeSetDisplayOrder($displayOrder)
    {
        $displayOrder = (string) $displayOrder;
        $app = Application::getFacadeApplication();
        $db = $app->make(Connection::class);
        $db->update('BlockTypeSets', ['btsDisplayOrder' => $displayOrder], ['btsID' => $this->getBlockTypeSetID()]);
    }
1099448
public ByteOrder order(ByteOrder o) {
        // TODO: In the next release, return WrappedByteBuffer - use return _buf.order(o)
        _isBigEndian = "BIG_ENDIAN".equals(o.toString());
        _buf.order(o);
        return o;
    }
485622
public function set_sortorder($sortorder) {
        if ($this->sortorder == $sortorder) {
            return;
        }
        $this->sortorder = $sortorder;
        $this->update();
    }
218068
public function addOrders( $orders )
	{
		if( !is_array( $orders ) )
			throw new InvalidArgumentException( 'An Array should be given.' );
		foreach( $orders as $column => $direction )
			$this->addOrder( $column, $direction );
	}
1135969
public function duplicateOrder(OrderInterface $oldOrder)
    {
        $newOrder = $this->createOrder();

        $newOrder->setChannel($oldOrder->getChannel());
        $newOrder->setCustomer($oldOrder->getCustomer());
        $newOrder->setCurrencyCode($oldOrder->getCurrencyCode());
        $newOrder->setLocaleCode($oldOrder->getLocaleCode());
        $newOrder->setBillingAddress(clone $oldOrder->getBillingAddress());
        $newOrder->setShippingAddress(clone $oldOrder->getShippingAddress());

        $this->copyShipment($oldOrder, $newOrder);
        $this->copyPayment($oldOrder, $newOrder);

        foreach ($oldOrder->getPromotions() as $oPro) {
            $newOrder->addPromotion(clone $oPro);
        }

        foreach ($oldOrder->getAdjustments() as $oAdjust) {
            $newOrder->addAdjustment(clone $oAdjust);
        }

        $this->copyOrderItem($oldOrder, $newOrder);

        return $newOrder;
    }
204058
public function &orderBy($order_by)
    {
        if (empty($order_by)) {
            throw new InvalidArgumentException('Order by value is required');
        } elseif (!is_string($order_by) && !is_array($order_by)) {
            throw new InvalidArgumentException('Order by can be string or array');
        }

        $this->order_by = (array) $order_by;

        return $this;
    }
1067717
public function initHasSortOrder()
    {
        $this->fillable = array_merge($this->fillable, $this->hasSortOrderFillableFields);
        $this->casts = array_merge($this->casts, $this->hasSortOrderCastFields);
    }
124403
protected function fillByteOrderMarks()
    {
        $this->byteOrderMarks = [
            self::UTF32_BIG_ENDIAN      => chr(0x00) . chr(0x00) . chr(0xFE) . chr(0xFF),
            self::UTF32_LITTLE_ENDIAN   => chr(0xFF) . chr(0xFE) . chr(0x00) . chr(0x00),
            self::UTF16_BIG_ENDIAN      => chr(0xFE) . chr(0xFF),
            self::UTF16_LITTLE_ENDIAN   => chr(0xFF) . chr(0xFE),
            self::UTF8                  => chr(0xEF) . chr(0xBB) . chr(0xBF)
        ];
    }
269870
public void order(Orderer orderer) throws InvalidOrderingException {
        if (getTest() instanceof Orderable) {
            Orderable adapter = (Orderable) getTest();
            adapter.order(orderer);
        }
    }