Source: lib/time.js

  1. // Copyright (c) 2018 Intel Corporation. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //     http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. 'use strict';
  17. const rclnodejs = require('bindings')('rclnodejs');
  18. const Duration = require('./duration.js');
  19. const ClockType = require('./clock_type.js');
  20. const S_TO_NS = 10n ** 9n;
  22. /**
  23.  * @class - Class representing a Time in ROS
  24.  */
  26. class Time {
  27.   /**
  28.    * Create a Time.
  29.    * @param {bigint} [seconds=0] - The second part of the time.
  30.    * @param {bigint} [nanoseconds=0] - The nanosecond part of the time.
  31.    * @param {ClockType} [clockType=Clock.ClockType.SYSTEM_TIME] - The clock type.
  32.    */
  33.   constructor(
  34.     seconds = 0n,
  35.     nanoseconds = 0n,
  36.     clockType = ClockType.SYSTEM_TIME
  37.   ) {
  38.     if (typeof seconds !== 'bigint') {
  39.       throw new TypeError('Invalid argument of seconds');
  40.     }
  42.     if (typeof nanoseconds !== 'bigint') {
  43.       throw new TypeError('Invalid argument of nanoseconds');
  44.     }
  46.     if (typeof clockType !== 'number') {
  47.       throw new TypeError('Invalid argument of clockType');
  48.     }
  50.     if (seconds < 0n) {
  51.       throw new RangeError('seconds value must not be negative');
  52.     }
  54.     if (nanoseconds < 0n) {
  55.       throw new RangeError('nanoseconds value must not be negative');
  56.     }
  58.     const total = seconds * S_TO_NS + nanoseconds;
  59.     if (total >= 2n ** 63n) {
  60.       throw new RangeError(
  61.         'Total nanoseconds value is too large to store in C time point.'
  62.       );
  63.     }
  64.     this._nanoseconds = total;
  65.     this._handle = rclnodejs.createTimePoint(this._nanoseconds, clockType);
  66.     this._clockType = clockType;
  67.   }
  69.   /**
  70.    * Get the the clock type of the Time object.
  71.    * @name Time#get:clockType
  72.    * @function
  73.    * @return {ClockType} - The clock type.
  74.    */
  76.   get clockType() {
  77.     return this._clockType;
  78.   }
  80.   /**
  81.    * Get the nanosecond part of the time.
  82.    * @name Time#get:nanoseconds
  83.    * @function
  84.    * @return {bigint} - value in nanosecond.
  85.    */
  87.   get nanoseconds() {
  88.     return rclnodejs.getNanoseconds(this._handle);
  89.   }
  91.   /**
  92.    * Get the time as separate seconds and nanoseconds component.
  93.    * @name Time#get:secondsAndNanoseconds
  94.    * @function
  95.    * @return {object} - object with properties seconds and nanoseconds.
  96.    */
  98.   get secondsAndNanoseconds() {
  99.     const nanoseconds = this._nanoseconds;
  100.     return {
  101.       seconds: nanoseconds / S_TO_NS,
  102.       nanoseconds: nanoseconds % S_TO_NS,
  103.     };
  104.   }
  106.   /**
  107.    * Add a duration to this time object.
  108.    * @param {Duration} other - The Duration object to be added.
  109.    * @return {Time} Return the result of a new Time object.
  110.    */
  111.   add(other) {
  112.     if (other instanceof Duration) {
  113.       return new Time(
  114.         0n,
  115.         this._nanoseconds + other.nanoseconds,
  116.         this._clockType
  117.       );
  118.     }
  119.     throw new TypeError('Invalid argument');
  120.   }
  122.   /**
  123.    * Subtract a duration/time to this time object.
  124.    * @param {Duration|Time} other - The time to be subtracted.
  125.    * @return {Duration|Time} Return the result.
  126.    */
  127.   sub(other) {
  128.     if (other instanceof Time) {
  129.       if (other._clockType !== this._clockType) {
  130.         throw new TypeError("Can't subtract times with different clock types");
  131.       }
  132.       return new Duration(0n, this._nanoseconds - other._nanoseconds);
  133.     } else if (other instanceof Duration) {
  134.       return new Time(
  135.         0n,
  136.         this._nanoseconds - other._nanoseconds,
  137.         this._clockType
  138.       );
  139.     }
  140.     throw new TypeError('Invalid argument');
  141.   }
  143.   /**
  144.    * Determine whether two Time objects are equal.
  145.    * @param {Time} other - The time object to be compared.
  146.    * @return {boolean} Return true if they are equal.
  147.    */
  148.   eq(other) {
  149.     if (other instanceof Time) {
  150.       if (other._clockType !== this._clockType) {
  151.         throw new TypeError("Can't compare times with different clock types");
  152.       }
  153.       return this._nanoseconds === other.nanoseconds;
  154.     }
  155.     throw new TypeError('Invalid argument');
  156.   }
  158.   /**
  159.    * Determine whether two Time objects are not equal.
  160.    * @param {Time} other - The time object to be compared.
  161.    * @return {boolean} Return true if they are not equal.
  162.    */
  163.   ne(other) {
  164.     if (other instanceof Time) {
  165.       if (other._clockType !== this._clockType) {
  166.         throw new TypeError("Can't compare times with different clock types");
  167.       }
  168.       return this._nanoseconds !== other.nanoseconds;
  169.     }
  170.   }
  172.   /**
  173.    * Determine whether the time is less than another one.
  174.    * @param {Time} other - The time object to be compared.
  175.    * @return {boolean} Return true if it's less than other.
  176.    */
  177.   lt(other) {
  178.     if (other instanceof Time) {
  179.       if (other._clockType !== this._clockType) {
  180.         throw new TypeError("Can't compare times with different clock types");
  181.       }
  182.       return this._nanoseconds < other.nanoseconds;
  183.     }
  184.     throw new TypeError('Invalid argument');
  185.   }
  187.   /**
  188.    * Determine whether the time is less than or equal with another one.
  189.    * @param {Time} other - The time object to be compared.
  190.    * @return {boolean} Return true if it's less than or equal with other.
  191.    */
  192.   lte(other) {
  193.     if (other instanceof Time) {
  194.       if (other._clockType !== this._clockType) {
  195.         throw new TypeError("Can't compare times with different clock types");
  196.       }
  197.       return this._nanoseconds <= other.nanoseconds;
  198.     }
  199.     throw new TypeError('Invalid argument');
  200.   }
  202.   /**
  203.    * Determine whether the time is greater than another one.
  204.    * @param {Time} other - The time object to be compared.
  205.    * @return {boolean} Return true if it's greater than other.
  206.    */
  207.   gt(other) {
  208.     if (other instanceof Time) {
  209.       if (other._clockType !== this._clockType) {
  210.         throw new TypeError("Can't compare times with different clock types");
  211.       }
  212.       return this._nanoseconds > other.nanoseconds;
  213.     }
  214.     throw new TypeError('Invalid argument');
  215.   }
  217.   /**
  218.    * Determine whether the time is greater than or equal with another one.
  219.    * @param {Time} other - The time object to be compared.
  220.    * @return {boolean} Return true if it's greater than or equal with other.
  221.    */
  222.   gte(other) {
  223.     if (other instanceof Time) {
  224.       if (other._clockType !== this._clockType) {
  225.         throw new TypeError("Can't compare times with different clock types");
  226.       }
  227.       return this._nanoseconds >= other.nanoseconds;
  228.     }
  229.     throw new TypeError('Invalid argument');
  230.   }
  232.   /**
  233.    * Create a builtin_interfaces.msg.Time message
  234.    *
  235.    * @return {builtin_interfaces.msg.Time} - The new Time message.
  236.    */
  237.   toMsg() {
  238.     const secondsAndNanoseconds = this.secondsAndNanoseconds;
  239.     return {
  240.       sec: secondsAndNanoseconds.seconds,
  241.       nanosec: secondsAndNanoseconds.nanoseconds,
  242.     };
  243.   }
  245.   /**
  246.    * Create a Time object from a message of builtin_interfaces/msg/Time
  247.    * @param {object} msg - The builtin_interfaces.msg.Time message to be
  248.    *  created from.
  249.    * @param {ClockType} [clockType=Clock.ClockType.ROS_TIME] - The type of the time object.
  250.    * @return {Time} Return the created Time object.
  251.    */
  252.   static fromMsg(msg, clockType = ClockType.ROS_TIME) {
  253.     return new Time(BigInt(msg.sec), BigInt(msg.nanosec), clockType);
  254.   }
  255. }
  257. module.exports = Time;