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
  61.       .from(seconds)
  62.       .multiply(1e9)
  63.       .add(nanoseconds);
  64.     this._handle = rclnodejs.createTimePoint(
  65.       this._nanoseconds.toString(),
  66.       clockType
  67.     );
  68.     this._clockType = clockType;
  69.   }
  71.   /**
  72.    * Get the the clock type of the Time object.
  73.    * @name Time#get:clockType
  74.    * @function
  75.    * @return {ClockType} - The clock type.
  76.    */
  78.   get clockType() {
  79.     return this._clockType;
  80.   }
  82.   /**
  83.    * Get the nanosecond part of the time.
  84.    * @name Time#get:nanoseconds
  85.    * @function
  86.    * @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.
  87.    */
  89.   get nanoseconds() {
  90.     let str = rclnodejs.getNanoseconds(this._handle);
  91.     let nano;
  93.     if (str.startsWith('-')) {
  94.       nano = int64.negative(int64.from(str));
  95.     } else {
  96.       nano = int64.from(str);
  97.     }
  98.     if (Number.isFinite(nano.toNumber())) {
  99.       return nano.toNumber();
  100.     }
  101.     return nano.toString();
  102.   }
  104.   /**
  105.    * Get the time as separate seconds and nanoseconds component.
  106.    * @name Time#get:secondsAndNanoseconds
  107.    * @function
  108.    * @return {object} - object with properties seconds and nanoseconds.
  109.    */
  111.   get secondsAndNanoseconds() {
  112.     const seconds = int64
  113.       .from(this._nanoseconds)
  114.       .divide(1e9)
  115.       .toNumber();
  116.     const nanoseconds = int64
  117.       .from(this._nanoseconds)
  118.       .mod(1e9)
  119.       .toNumber();
  120.     return { seconds, nanoseconds };
  121.   }
  123.   /**
  124.    * Add a duration to this time object.
  125.    * @param {Duration} other - The Duration object to be added.
  126.    * @return {Time} Return the result of a new Time object.
  127.    */
  128.   add(other) {
  129.     if (other instanceof Duration) {
  130.       return new Time(
  131.         0,
  132.         int64.add(this._nanoseconds, other.nanoseconds).toString(),
  133.         this._clockType
  134.       );
  135.     }
  136.     throw new TypeError('Invalid argument');
  137.   }
  139.   /**
  140.    * Subtract a duration/time to this time object.
  141.    * @param {Duration|Time} other - The time to be subtracted.
  142.    * @return {Duration|Time} Return the result.
  143.    */
  144.   sub(other) {
  145.     if (other instanceof Time) {
  146.       if (other._clockType !== this._clockType) {
  147.         throw new TypeError("Can't subtract times with different clock types");
  148.       }
  149.       return new Duration(
  150.         0,
  151.         int64.subtract(this._nanoseconds, other._nanoseconds).toString()
  152.       );
  153.     } else if (other instanceof Duration) {
  154.       return new Time(
  155.         0,
  156.         int64.subtract(this._nanoseconds, other._nanoseconds).toString(),
  157.         this._clockType
  158.       );
  159.     }
  160.     throw new TypeError('Invalid argument');
  161.   }
  163.   /**
  164.    * Determine whether two Time objects are equal.
  165.    * @param {Time} other - The time object to be compared.
  166.    * @return {boolean} Return true if they are equal.
  167.    */
  168.   eq(other) {
  169.     if (other instanceof Time) {
  170.       if (other._clockType !== this._clockType) {
  171.         throw new TypeError("Can't compare times with different clock types");
  172.       }
  173.       return this._nanoseconds.eq(other.nanoseconds);
  174.     }
  175.     throw new TypeError('Invalid argument');
  176.   }
  178.   /**
  179.    * Determine whether two Time objects are not equal.
  180.    * @param {Time} other - The time object to be compared.
  181.    * @return {boolean} Return true if they are not equal.
  182.    */
  183.   ne(other) {
  184.     if (other instanceof Time) {
  185.       if (other._clockType !== this._clockType) {
  186.         throw new TypeError("Can't compare times with different clock types");
  187.       }
  188.       return this._nanoseconds.ne(other.nanoseconds);
  189.     }
  190.   }
  192.   /**
  193.    * Determine whether the time is less than another one.
  194.    * @param {Time} other - The time object to be compared.
  195.    * @return {boolean} Return true if it's less than other.
  196.    */
  197.   lt(other) {
  198.     if (other instanceof Time) {
  199.       if (other._clockType !== this._clockType) {
  200.         throw new TypeError("Can't compare times with different clock types");
  201.       }
  202.       return this._nanoseconds.lt(other.nanoseconds);
  203.     }
  204.     throw new TypeError('Invalid argument');
  205.   }
  207.   /**
  208.    * Determine whether the time is less than or equal with another one.
  209.    * @param {Time} other - The time object to be compared.
  210.    * @return {boolean} Return true if it's less than or equal with other.
  211.    */
  212.   lte(other) {
  213.     if (other instanceof Time) {
  214.       if (other._clockType !== this._clockType) {
  215.         throw new TypeError("Can't compare times with different clock types");
  216.       }
  217.       return this._nanoseconds.lte(other.nanoseconds);
  218.     }
  219.     throw new TypeError('Invalid argument');
  220.   }
  222.   /**
  223.    * Determine whether the time is greater than another one.
  224.    * @param {Time} other - The time object to be compared.
  225.    * @return {boolean} Return true if it's greater than other.
  226.    */
  227.   gt(other) {
  228.     if (other instanceof Time) {
  229.       if (other._clockType !== this._clockType) {
  230.         throw new TypeError("Can't compare times with different clock types");
  231.       }
  232.       return this._nanoseconds.gt(other.nanoseconds);
  233.     }
  234.     throw new TypeError('Invalid argument');
  235.   }
  237.   /**
  238.    * Determine whether the time is greater than or equal with another one.
  239.    * @param {Time} other - The time object to be compared.
  240.    * @return {boolean} Return true if it's greater than or equal with other.
  241.    */
  242.   gte(other) {
  243.     if (other instanceof Time) {
  244.       if (other._clockType !== this._clockType) {
  245.         throw new TypeError("Can't compare times with different clock types");
  246.       }
  247.       return this._nanoseconds.gte(other.nanoseconds);
  248.     }
  249.     throw new TypeError('Invalid argument');
  250.   }
  252.   /**
  253.    * Create a builtin_interfaces.msg.Time message
  254.    *
  255.    * @return {builtin_interfaces.msg.Time} - The new Time message.
  256.    */
  257.   toMsg() {
  258.     const secondsAndNanoseconds = this.secondsAndNanoseconds;
  259.     return {
  260.       sec: secondsAndNanoseconds.seconds,
  261.       nanosec: secondsAndNanoseconds.nanoseconds,
  262.     };
  263.   }
  265.   /**
  266.    * Create a Time object from a message of builtin_interfaces/msg/Time
  267.    * @param {object} msg - The builtin_interfaces.msg.Time message to be
  268.    *  created from.
  269.    * @param {ClockType} [clockType=Clock.ClockType.ROS_TIME] - The type of the time object.
  270.    * @return {Time} Return the created Time object.
  271.    */
  272.   static fromMsg(msg, clockType = ClockType.ROS_TIME) {
  273.     return new Time(msg.sec, msg.nanosec, clockType);
  274.   }
  275. }
  277. module.exports = Time;