If you want to ride/have your bike with you.

@param int $originDistance      Cycling distance at origin, in meters, min 500, max 20.000
@param int $destinationDistance Cycling distance at destination, in meters, min 500, max 20.000

@return $this
768561
public function setUseBicycle(int $originDistance = 5000, int $destinationDistance = 5000): self
    {
        $this->options['useBicycle'] = 1;
        $this->options['maxCyclingDistanceDep'] = $originDistance;
        $this->options['maxCyclingDistanceDest'] = $destinationDistance;

        return $this;
    }
1212414
public function sdiffstore($destination, array $sources) {
        try {
            return call_user_func_array(array(
                $this->getRedis(),
                'sDiffStore',
            ), array_merge(array($destination), $sources));
        } catch (RedisException $ex) {
            throw new ConnectException();
        }
    }
19794
protected function move($destination)
    {
        if ($previousRow = static::orderModel()->findByPosition($this->getOrderValue() - $destination)->first()) {
            $previousRow->{$this->getOrderField()} += $destination;
            $previousRow->save();
        }

        $this->{$this->getOrderField()} -= $destination;
        $this->save();
    }
879190
public function createConsumer(DestinationInterface $destination)
    {
        InvalidDestinationException::assertDestinationInstanceOf($destination, DbalDestination::class);

        $consumer = new DbalMessageConsumer($this, $destination);

        if (isset($this->connection->getOptions()['polling_interval'])) {
            $consumer->setPollingInterval($this->connection->getOptions()['polling_interval']);
        }

        return $consumer;
    }
684986
public function setDestinationCity($destinationCity)
    {
        $destinationCity = trim($destinationCity);
        if (is_string($destinationCity) && strlen($destinationCity) > 0) {
            $this->destinationCity = $destinationCity;

            return true;
        }
        $this->destinationCity = null;

        return false;
    }
749321
public function destination($path, $override_chroot = false) {
		// set the path
		$this->Destination = Filesystem::chroot($path, $override_chroot);
		// return self
		return($this);
	}
817211
public function createConsumer(Destination $destination): Consumer
    {
        InvalidDestinationException::assertDestinationInstanceOf($destination, RdKafkaTopic::class);

        $this->kafkaConsumers[] = $kafkaConsumer = new KafkaConsumer($this->getConf());

        $consumer = new RdKafkaConsumer(
            $kafkaConsumer,
            $this,
            $destination,
            $this->getSerializer()
        );

        if (isset($this->config['commit_async'])) {
            $consumer->setCommitAsync($this->config['commit_async']);
        }

        return $consumer;
    }
364508
public function distanceOffset($offset = 0)
    {
        // Return value
        if (empty($offset)) {
            return $this->distanceOffset;
        }

        // Set value
        $this->distanceOffset = $offset;

        return $this;
    }
793447
public static function assertDestinationInstanceOf($destination, string $class): void
    {
        if (!$destination instanceof $class) {
            throw new static(sprintf(
                'The destination must be an instance of %s but got %s.',
                $class,
                is_object($destination) ? get_class($destination) : gettype($destination)
            ));
        }
    }
964368
function _tripGoesTo(trip, origin, destination) {
  let originFound = false;
  for ( let i = 0; i < trip.stopTimes.length; i++ ) {
    if ( !originFound && trip.stopTimes[i].stop.id === origin.id ) {
      originFound = true;
    }
    else if ( originFound ) {
      if ( trip.stopTimes[i].stop.id === destination.id ) {
        return true;
      }
    }
  }
  return false;
}
529107
public function createConsumer(Destination $destination): Consumer
    {
        InvalidDestinationException::assertDestinationInstanceOf($destination, GearmanDestination::class);

        $this->consumers[] = $consumer = new GearmanConsumer($this, $destination);

        return $consumer;
    }
178231
protected function duplicateHasOneRelation($sourceObject, $destinationObject, $relation)
    {
        // Check if original object exists
        $item = $sourceObject->getComponent($relation);
        if (!$item->isInDB()) {
            return;
        }

        $clonedItem = $item->duplicate(false);
        $destinationObject->setComponent($relation, $clonedItem);
    }
710217
private function setShadowDistance($distance)
    {
        if ($distance !== null) {
            $this->shadowProperties['distance'] = (string) $this->getExcelPointsWidth($distance);
        }

        return $this;
    }
336568
public function createConsumer(Destination $destination): Consumer
    {
        InvalidDestinationException::assertDestinationInstanceOf($destination, FsDestination::class);

        $consumer = new FsConsumer($this, $destination, $this->preFetchCount);

        if ($this->pollingInterval) {
            $consumer->setPollingInterval($this->pollingInterval);
        }

        return $consumer;
    }
952323
public function send($destination, Message $message)
    {
        return $this->getClient()->send($destination, $message, ['transaction' => $this->transactionId], false);
    }
666364
public function enableRateLimiting(int $cycle = null, int $buffer = null)
    {
        $this->rateLimitingEnabled = true;

        if (!is_null($cycle)) {
            $this->rateLimitCycle = $cycle;
        }

        if (!is_null($cycle)) {
            $this->rateLimitCycleBuffer = $buffer;
        }

        return $this;
    }
275658
public function setAddressDestination(\Core\Entity\Address $address_destination = null) {
        $this->address_destination = $address_destination;

        return $this;
    }