Specify an interval in the IntervalUnit.MINUTE that the produced
Trigger will repeat at.

@param int $intervalInMinutes the number of minutes at which the trigger should repeat.

@return CalendarIntervalScheduleBuilder
341735
public function withIntervalInMinutes($intervalInMinutes)
    {
        $this->validateInterval($intervalInMinutes);
        $this->interval = $intervalInMinutes;
        $this->intervalUnit = IntervalUnit::MINUTE;

        return $this;
    }
1173615
public function setTime($hour, $minute, $second = null)
    {
        if (self::$_immutable) {
            self::$_immutable = false;
            $newDate = clone $this;
            $newDate->setTime($hour, $minute, $second);
            self::$_immutable = true;

            return $newDate;
        } else {
            return parent::setTime($hour, $minute, $second);
        }
    }
970735
public function add(string $interval, $format = ''){
    $tmp  = new \bbn\time($this->format());
    $tmp->time->add($this->get_interval($interval));
    return $tmp->format($format);
  }
248895
public static function createIntervalFromSpec($interval_spec)
	{
		return	isset(static::$intervals[$interval_spec])
				?	static::$intervals[$interval_spec]
				:	static::$intervals[$interval_spec] = new \DateInterval($interval_spec);
	}
209814
public static function intervalToTime(DateInterval $interval)
    {
        $time = null;

        if (!is_null($interval)) {
            $format = property_exists(get_class($interval), 'u') ? '%H:%I:%S.%U' : '%H:%I:%S';
            $time = $interval->format($format);
        }

        return $time;
    }
487725
public function add($interval)
    {
        parent::add($interval);

        if ($interval instanceof DateInterval) {
            if ($interval->invert) { // is negative, then sub
                $this->subMicroseconds($interval->u);
            } else {
                $this->addMicroseconds($interval->u);
            }
        }

        return $this;
    }
1282502
public static function repeatSecondlyForTotalCount($count, $seconds = 1) {
        if($count < 1) {
            throw new \InvalidArgumentException(sprintf('Total count of firings must be at least one! Given count: "%s"', $count));
        }

        return static::simpleSchedule()
            ->withIntervalInSeconds($seconds)
            ->withRepeatCount($count - 1);
    }
54253
public function withInterval($timeInterval, $unit)
    {
        DateBuilder::validateIntervalUnit($unit);
        $this->validateInterval($timeInterval);

        $this->interval = $timeInterval;
        $this->intervalUnit = $unit;

        return $this;
    }
1101729
public static function toSecondsUsingDays(\DateInterval $interval)
    {
        $seconds = (string) $interval->s;

        if ($interval->i) {
            $seconds = bcadd($seconds, bcmul($interval->i, self::SECONDS_MINUTE));
        }

        if ($interval->h) {
            $seconds = bcadd($seconds, bcmul($interval->h, self::SECONDS_HOUR));
        }

        if ((false !== $interval->days) && (0 <= $interval->days)) {
            $seconds = bcadd($seconds, bcmul($interval->days, self::SECONDS_DAY));
        } else {
            throw new InvalidArgumentException(
                'The "days" property is not set.'
            );
        }

        return $seconds;
    }
128408
final public static function secondsToInterval($sec)
    {
        try {
            return self::recalculateInterval(new \DateInterval(sprintf('PT%dS', intval($sec))));
        } catch (\Exception $e) {
            return null;
        }
    }
1208147
def set_interval(self, interval):
        """"""
        self._interval = interval
        if self.timer is not None:
            self.timer.setInterval(interval)
1118222
public function setInterval($unit = self::INTERVAL_MONTH, $length = 1)
    {
        $this->data->interval = new stdClass;
        $this->data->interval->unit = $unit;
        $this->data->interval->length = $length;

        return $this;
    }
397939
public function setMin($min)
  {
    if (!is_numeric($min))
    {
      $min = null;
    }
    $this->min = $min;

    return $this;
  }
140445
public function withMinute(int $minute) : LocalDateTime
    {
        $time = $this->time->withMinute($minute);

        if ($time === $this->time) {
            return $this;
        }

        return new LocalDateTime($this->date, $time);
    }
843184
public function add(TimeInterval $interval)
    {
        $date = clone $this->date;
        $int = new DateInterval($interval->intervalSpec());
        $date->add($int);
        return $this->dateTimeToTimePoint($date);
    }
760201
private function intervalToSeconds(DateInterval $interval): int
    {
        $seconds = (int) $interval->format('%s');

        $multiplier = 60;
        $seconds += (int) $interval->format('%i') * $multiplier;

        $multiplier *= 60;
        $seconds += (int) $interval->format('%h') * $multiplier;

        $multiplier *= 24;
        $seconds += (int) $interval->format('%d') * $multiplier;

        $multiplier *= 30;
        $seconds += (int) $interval->format('%m') * $multiplier;

        $multiplier *= 12;
        $seconds += (int) $interval->format('%y') * $multiplier;

        return $seconds;
    }
616473
public function setTime($hour, $minute, $second = 0)
        {
            parent::setTime($hour, $minute, $second);

            return $this;
        }