PHP DateTimeInterface::getTimestamp方法代码示例

 /**
  * Calculate the number of seconds with the given delay.
  *
  * @param int|\DateTimeInterface $delay
  *
  * @return int
  */
 protected function getSeconds($delay) : int
 {
     if ($delay instanceof DateTimeInterface) {
         return max(0, $delay->getTimestamp() - $this->getTime());
     }
     return (int) $delay;
 }

 /**
  * @return \stdClass
  */
 private function getSerializedDirectMessageDelete()
 {
     $serializedTweetDelete = new \stdClass();
     $serializedTweetDelete->delete = new \stdClass();
     $serializedTweetDelete->delete->direct_message = new \stdClass();
     $serializedTweetDelete->delete->direct_message->id = $this->id;
     $serializedTweetDelete->delete->direct_message->user_id = $this->userId;
     $serializedTweetDelete->delete->timestamp_ms = $this->date->getTimestamp() * 1000;
     return $serializedTweetDelete;
 }

 public function __construct(\DateTimeInterface $date = NULL)
 {
     if ($date === NULL) {
         $this->date = new \DateTimeImmutable();
     } else {
         $this->date = new \DateTimeImmutable('@' . $date->getTimestamp(), $date->getTimezone());
     }
 }

 public function setDueDate(\DateTimeInterface $dueDate = NULL)
 {
     if ($dueDate === NULL) {
         $this->dueDate = NULL;
     } else {
         $this->dueDate = $dueDate->getTimestamp();
     }
 }

 /**
  * @param string $token
  * @param \DateTimeInterface $expiry
  */
 public function __construct($token, \DateTimeInterface $expiry)
 {
     $this->token = $token;
     if ($expiry instanceof \DateTimeImmutable) {
         $this->expiry = $expiry;
     } else {
         $this->expiry = new \DateTimeImmutable('@' . $expiry->getTimestamp());
     }
 }

 /**
  * Set the date-time of the Date in this Header.
  *
  * If a DateTime instance is provided, it is converted to DateTimeImmutable.
  *
  * @param DateTimeInterface $dateTime
  */
 public function setDateTime(DateTimeInterface $dateTime)
 {
     $this->clearCachedValueIf($this->getCachedValue() != $dateTime->format(DateTime::RFC2822));
     if ($dateTime instanceof DateTime) {
         $immutable = new DateTimeImmutable('@' . $dateTime->getTimestamp());
         $dateTime = $immutable->setTimezone($dateTime->getTimezone());
     }
     $this->dateTime = $dateTime;
 }

 /**
  * Transforms a DateTime object into a timestamp in the configured timezone.
  *
  * @param \DateTime|\DateTimeInterface $dateTime A DateTime object
  *
  * @return int A timestamp
  *
  * @throws TransformationFailedException If the given value is not an instance
  *                                       of \DateTime or \DateTimeInterface
  */
 public function transform($dateTime)
 {
     if (null === $dateTime) {
         return;
     }
     if (!$dateTime instanceof \DateTime && !$dateTime instanceof \DateTimeInterface) {
         throw new TransformationFailedException('Expected a \\DateTime or \\DateTimeInterface.');
     }
     return $dateTime->getTimestamp();
 }

 /**
  * {@inheritdoc}
  */
 public function jsonSerialize()
 {
     $expires_at = null;
     if ($this->expires_at instanceof JsonSerializable) {
         $expires_at = $this->expires_at->jsonSerialize();
     } elseif ($this->expires_at instanceof DateTimeInterface) {
         $expires_at = $this->expires_at->getTimestamp();
     }
     return ['session_id' => $this->session_id, 'user_id' => $this->user_id, 'expires_at' => $expires_at];
 }

 /**
  * @param string|\DateTimeInterface $date
  *
  * @return string
  */
 public function getDateFormatted($date) : string
 {
     if ($date instanceof \DateTimeInterface) {
         return $this->formatter->format($date->getTimestamp());
     } elseif (is_string($date)) {
         return $this->formatter->format(strtotime($date));
     } else {
         return '';
     }
 }

 /**
  * Returns the difference between two Period objects.
  *
  * @param \Thin\Period $period
  * @param bool                  $get_as_seconds If used and set to true, the method will return
  *                                              an intw hich represents the duration in seconds
  *                                              instead of a\DateInterval object
  *
  * @return \DateInterval|int
  */
 public function durationDiff(Period $period, $get_as_seconds = false)
 {
     $diff = $this->end->getTimestamp() - $this->start->getTimestamp() - $period->end->getTimestamp() + $period->start->getTimestamp();
     if (!$get_as_seconds) {
         $res = new DateInterval('PT' . abs($diff) . 'S');
         if (0 > $diff) {
             $res->invert = 1;
         }
         return $res;
     }
     return $diff;
 }

 /**
  * Transforms a normalized date into a localized date string/array.
  *
  * @param \DateTimeInterface $dateTime A DateTimeInterface object
  *
  * @return string|array Localized date string/array
  *
  * @throws TransformationFailedException If the given value is not a \DateTimeInterface
  *                                       or if the date could not be transformed.
  */
 public function transform($dateTime)
 {
     if (null === $dateTime) {
         return '';
     }
     if (!$dateTime instanceof \DateTimeInterface) {
         throw new TransformationFailedException('Expected a \\DateTimeInterface.');
     }
     $value = $this->getIntlDateFormatter()->format($dateTime->getTimestamp());
     if (intl_get_error_code() != 0) {
         throw new TransformationFailedException(intl_get_error_message());
     }
     return $value;
 }

 /**
  * Created a timer event subscription backed by a scheduled job.
  * 
  * @param \DateTimeInterface $time Schedule date.
  * @param VirtualExecution $execution Target execution.
  * @param string $activityId ID of the activity that created the event subscription.
  * @param Node $node Target node to receive the delegated signal or NULL in order to use the activity node.
  * @param boolean $boundaryEvent Is this a subscription for a boundary event?
  */
 public function __construct(\DateTimeInterface $time, VirtualExecution $execution, $activityId, Node $node = NULL, $boundaryEvent = false)
 {
     parent::__construct('timer', $execution, $activityId, $node, $boundaryEvent);
     $this->time = $time->getTimestamp();
 }

 protected function computeExpires(\DateTimeInterface $expires = NULL)
 {
     // TODO: Lock min / max timeouts must be configurable.
     $min = new \DateTimeImmutable('+2 minutes');
     if ($expires === NULL || $expires < $min) {
         return $min;
     }
     $max = new \DateTimeImmutable('+2 hours');
     if ($expires > $max) {
         return $max;
     }
     return new \DateTimeImmutable('@' . $expires->getTimestamp(), $expires->getTimezone());
 }

 public function setExpires(\DateTimeInterface $expires)
 {
     $this->expires = new \DateTimeImmutable('@' . $expires->getTimestamp(), $expires->getTimezone());
 }

 public function receiveDueCommands(\DateTimeInterface $now, int $limit = SchedulerWorker::DEFAULT_THROTTLE, \DateTimeInterface $startTime = null) : array
 {
     if ($startTime === null) {
         $start = 0;
     } else {
         $start = $startTime->getTimestamp();
     }
     $results = $this->evalScript('receive_due_messages', [$this->namespace, $start, $now->getTimestamp(), $limit]);
     $commands = [];
     foreach ($results as $result) {
         list($queueName, $id, $message, $score) = $result;
         $commands[] = new ReceivedScheduledCommand($queueName, $id, $message, new \DateTimeImmutable('@' . $score));
     }
     return $commands;
 }