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 int64 = require('int64-napi');
  22. /**
  23.  * @class - Class representing a Time in ROS
  24.  */
  26. class Time {
  27.   /**
  28.    * Create a Time.
  29.    * @param {number|string} [seconds=0] - The second part of the time.
  30.    * @param {number|string} [nanoseconds=0] - The nanosecond part of the time.
  31.    * @param {ClockType} [clockType=Clock.ClockType.SYSTEM_TIME] - The clock type.
  32.    */
  33.   constructor(seconds = 0, nanoseconds = 0, clockType = ClockType.SYSTEM_TIME) {
  34.     if (typeof seconds !== 'number' && typeof seconds !== 'string') {
  35.       throw new TypeError('Invalid argument of seconds');
  36.     }
  38.     if (typeof nanoseconds !== 'number' && typeof nanoseconds !== 'string') {
  39.       throw new TypeError('Invalid argument of nanoseconds');
  40.     }
  42.     if (typeof clockType !== 'number') {
  43.       throw new TypeError('Invalid argument of clockType');
  44.     }
  46.     if (
  47.       int64.lt(seconds, 0) ||
  48.       (typeof seconds === 'string' && seconds.startsWith('-'))
  49.     ) {
  50.       throw new RangeError('seconds value must not be negative');
  51.     }
  53.     if (
  54.       int64.lt(nanoseconds, 0) ||
  55.       (typeof nanoseconds === 'string' && nanoseconds.startsWith('-'))
  56.     ) {
  57.       throw new RangeError('nanoseconds value must not be negative');
  58.     }
  60.     this._nanoseconds = int64.from(seconds).multiply(1e9).add(nanoseconds);
  61.     this._handle = rclnodejs.createTimePoint(
  62.       this._nanoseconds.toString(),
  63.       clockType
  64.     );
  65.     this._clockType = clockType;
  66.   }
  68.   /**
  69.    * Get the the clock type of the Time object.
  70.    * @name Time#get:clockType
  71.    * @function
  72.    * @return {ClockType} - The clock type.
  73.    */
  75.   get clockType() {
  76.     return this._clockType;
  77.   }
  79.   /**
  80.    * Get the nanosecond part of the time.
  81.    * @name Time#get:nanoseconds
  82.    * @function
  83.    * @return {number|string} - value in nanosecond, if the value is greater than Number.MAX_SAFE_INTEGER (2^53-1), will be presented in string of decimal format.
  84.    */
  86.   get nanoseconds() {
  87.     let str = rclnodejs.getNanoseconds(this._handle);
  88.     let nano;
  90.     if (str.startsWith('-')) {
  91.       nano = int64.negative(int64.from(str));
  92.     } else {
  93.       nano = int64.from(str);
  94.     }
  95.     if (Number.isFinite(nano.toNumber())) {
  96.       return nano.toNumber();
  97.     }
  98.     return nano.toString();
  99.   }
  101.   /**
  102.    * Get the time as separate seconds and nanoseconds component.
  103.    * @name Time#get:secondsAndNanoseconds
  104.    * @function
  105.    * @return {object} - object with properties seconds and nanoseconds.
  106.    */
  108.   get secondsAndNanoseconds() {
  109.     const seconds = int64.from(this._nanoseconds).divide(1e9).toNumber();
  110.     const nanoseconds = int64.from(this._nanoseconds).mod(1e9).toNumber();
  111.     return { seconds, nanoseconds };
  112.   }
  114.   /**
  115.    * Add a duration to this time object.
  116.    * @param {Duration} other - The Duration object to be added.
  117.    * @return {Time} Return the result of a new Time object.
  118.    */
  119.   add(other) {
  120.     if (other instanceof Duration) {
  121.       return new Time(
  122.         0,
  123.         int64.add(this._nanoseconds, other.nanoseconds).toString(),
  124.         this._clockType
  125.       );
  126.     }
  127.     throw new TypeError('Invalid argument');
  128.   }
  130.   /**
  131.    * Subtract a duration/time to this time object.
  132.    * @param {Duration|Time} other - The time to be subtracted.
  133.    * @return {Duration|Time} Return the result.
  134.    */
  135.   sub(other) {
  136.     if (other instanceof Time) {
  137.       if (other._clockType !== this._clockType) {
  138.         throw new TypeError("Can't subtract times with different clock types");
  139.       }
  140.       return new Duration(
  141.         0,
  142.         int64.subtract(this._nanoseconds, other._nanoseconds).toString()
  143.       );
  144.     } else if (other instanceof Duration) {
  145.       return new Time(
  146.         0,
  147.         int64.subtract(this._nanoseconds, other._nanoseconds).toString(),
  148.         this._clockType
  149.       );
  150.     }
  151.     throw new TypeError('Invalid argument');
  152.   }
  154.   /**
  155.    * Determine whether two Time objects are equal.
  156.    * @param {Time} other - The time object to be compared.
  157.    * @return {boolean} Return true if they are equal.
  158.    */
  159.   eq(other) {
  160.     if (other instanceof Time) {
  161.       if (other._clockType !== this._clockType) {
  162.         throw new TypeError("Can't compare times with different clock types");
  163.       }
  164.       return this._nanoseconds.eq(other.nanoseconds);
  165.     }
  166.     throw new TypeError('Invalid argument');
  167.   }
  169.   /**
  170.    * Determine whether two Time objects are not equal.
  171.    * @param {Time} other - The time object to be compared.
  172.    * @return {boolean} Return true if they are not equal.
  173.    */
  174.   ne(other) {
  175.     if (other instanceof Time) {
  176.       if (other._clockType !== this._clockType) {
  177.         throw new TypeError("Can't compare times with different clock types");
  178.       }
  179.       return this._nanoseconds.ne(other.nanoseconds);
  180.     }
  181.   }
  183.   /**
  184.    * Determine whether the time is less than another one.
  185.    * @param {Time} other - The time object to be compared.
  186.    * @return {boolean} Return true if it's less than other.
  187.    */
  188.   lt(other) {
  189.     if (other instanceof Time) {
  190.       if (other._clockType !== this._clockType) {
  191.         throw new TypeError("Can't compare times with different clock types");
  192.       }
  193.       return this._nanoseconds.lt(other.nanoseconds);
  194.     }
  195.     throw new TypeError('Invalid argument');
  196.   }
  198.   /**
  199.    * Determine whether the time is less than or equal with another one.
  200.    * @param {Time} other - The time object to be compared.
  201.    * @return {boolean} Return true if it's less than or equal with other.
  202.    */
  203.   lte(other) {
  204.     if (other instanceof Time) {
  205.       if (other._clockType !== this._clockType) {
  206.         throw new TypeError("Can't compare times with different clock types");
  207.       }
  208.       return this._nanoseconds.lte(other.nanoseconds);
  209.     }
  210.     throw new TypeError('Invalid argument');
  211.   }
  213.   /**
  214.    * Determine whether the time is greater than another one.
  215.    * @param {Time} other - The time object to be compared.
  216.    * @return {boolean} Return true if it's greater than other.
  217.    */
  218.   gt(other) {
  219.     if (other instanceof Time) {
  220.       if (other._clockType !== this._clockType) {
  221.         throw new TypeError("Can't compare times with different clock types");
  222.       }
  223.       return this._nanoseconds.gt(other.nanoseconds);
  224.     }
  225.     throw new TypeError('Invalid argument');
  226.   }
  228.   /**
  229.    * Determine whether the time is greater than or equal with another one.
  230.    * @param {Time} other - The time object to be compared.
  231.    * @return {boolean} Return true if it's greater than or equal with other.
  232.    */
  233.   gte(other) {
  234.     if (other instanceof Time) {
  235.       if (other._clockType !== this._clockType) {
  236.         throw new TypeError("Can't compare times with different clock types");
  237.       }
  238.       return this._nanoseconds.gte(other.nanoseconds);
  239.     }
  240.     throw new TypeError('Invalid argument');
  241.   }
  243.   /**
  244.    * Create a builtin_interfaces.msg.Time message
  245.    *
  246.    * @return {builtin_interfaces.msg.Time} - The new Time message.
  247.    */
  248.   toMsg() {
  249.     const secondsAndNanoseconds = this.secondsAndNanoseconds;
  250.     return {
  251.       sec: secondsAndNanoseconds.seconds,
  252.       nanosec: secondsAndNanoseconds.nanoseconds,
  253.     };
  254.   }
  256.   /**
  257.    * Create a Time object from a message of builtin_interfaces/msg/Time
  258.    * @param {object} msg - The builtin_interfaces.msg.Time message to be
  259.    *  created from.
  260.    * @param {ClockType} [clockType=Clock.ClockType.ROS_TIME] - The type of the time object.
  261.    * @return {Time} Return the created Time object.
  262.    */
  263.   static fromMsg(msg, clockType = ClockType.ROS_TIME) {
  264.     return new Time(msg.sec, msg.nanosec, clockType);
  265.   }
  266. }
  268. module.exports = Time;