Source: lib/duration.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 int64 = require('int64-napi');
  20. /**
  21.  * @class - Class representing a Duration in ROS
  22.  */
  24. class Duration {
  25.   /**
  26.    * Create a Duration.
  27.    * @param {number|string} [seconds=0] - The second part of the duration.
  28.    * @param {number|string} [nanoseconds=0] - The nanosecond part of the duration.
  29.    */
  30.   constructor(seconds = 0, nanoseconds = 0) {
  31.     if (typeof seconds !== 'number' && typeof seconds !== 'string') {
  32.       throw new TypeError('Invalid argument of seconds');
  33.     }
  35.     if (typeof nanoseconds !== 'number' && typeof nanoseconds !== 'string') {
  36.       throw new TypeError('Invalid argument of nanoseconds');
  37.     }
  39.     let secondInt64 = int64.from(seconds);
  40.     let nanoInt64 = int64.from(nanoseconds);
  42.     if (typeof seconds === 'string' && seconds.startsWith('-')) {
  43.       secondInt64 = int64.negative(secondInt64);
  44.     }
  45.     if (typeof nanoseconds === 'string' && nanoseconds.startsWith('-')) {
  46.       nanoInt64 = int64.negative(nanoInt64);
  47.     }
  48.     this._nanoseconds = secondInt64.multiply(1e9).add(nanoInt64);
  49.     this._handle = rclnodejs.createDuration(this._nanoseconds.toString());
  50.   }
  52.   /**
  53.    * Get the nanosecond part of the Duration.
  54.    * @name Duration#get:nanoseconds
  55.    * @function
  56.    * @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.
  57.    */
  59.   get nanoseconds() {
  60.     let nanoStr = rclnodejs.getDurationNanoseconds(this._handle);
  61.     let nano;
  63.     if (nanoStr.startsWith('-')) {
  64.       nano = int64.negative(int64.from(nanoStr));
  65.     } else {
  66.       nano = int64.from(nanoStr);
  67.     }
  68.     if (Number.isFinite(nano.toNumber())) {
  69.       return nano.toNumber();
  70.     }
  71.     return nano.toString();
  72.   }
  74.   /**
  75.    * Determine whether two Duration objects are equal.
  76.    * @param {Duration} other - The Duration object to be compared.
  77.    * @return {boolean} Return true if they are equal.
  78.    */
  79.   eq(other) {
  80.     if (other instanceof Duration) {
  81.       return this._nanoseconds.eq(other.nanoseconds);
  82.     }
  83.     throw new TypeError(
  84.       `Can't compare duration with object of type: ${other.constructor.name}`
  85.     );
  86.   }
  88.   /**
  89.    * Determine whether two Duration objects are not equal.
  90.    * @param {Duration} other - The Duration object to be compared.
  91.    * @return {boolean} Return true if they are not equal.
  92.    */
  93.   ne(other) {
  94.     if (other instanceof Duration) {
  95.       return this._nanoseconds.ne(other.nanoseconds);
  96.     }
  97.     throw new TypeError('Invalid argument');
  98.   }
  100.   /**
  101.    * Determine whether the Duration object is less than another one.
  102.    * @param {Duration} other - The Duration object to be compared.
  103.    * @return {boolean} Return true if it's less than other.
  104.    */
  105.   lt(other) {
  106.     if (other instanceof Duration) {
  107.       return this._nanoseconds.lt(other.nanoseconds);
  108.     }
  109.     throw new TypeError('Invalid argument');
  110.   }
  112.   /**
  113.    * Determine whether the Duration object is less than or equal with another one.
  114.    * @param {Duration} other - The Duration object to be compared.
  115.    * @return {boolean} Return true if it's less than or equal with other.
  116.    */
  117.   lte(other) {
  118.     if (other instanceof Duration) {
  119.       return this._nanoseconds.lte(other.nanoseconds);
  120.     }
  121.     throw new TypeError('Invalid argument');
  122.   }
  124.   /**
  125.    * Determine whether the Duration object is greater than another one.
  126.    * @param {Duration} other - The Duration object to be compared.
  127.    * @return {boolean} Return true if it's greater than other.
  128.    */
  129.   gt(other) {
  130.     if (other instanceof Duration) {
  131.       return this._nanoseconds.gt(other.nanoseconds);
  132.     }
  133.     throw new TypeError('Invalid argument');
  134.   }
  136.   /**
  137.    * Determine whether the Duration object is greater than or equal with another one.
  138.    * @param {Duration} other - The Duration object to be compared.
  139.    * @return {boolean} Return true if it's greater than or equal with other.
  140.    */
  141.   gte(other) {
  142.     if (other instanceof Duration) {
  143.       return this._nanoseconds.gte(other.nanoseconds);
  144.     }
  145.     throw new TypeError('Invalid argument');
  146.   }
  147. }
  149. module.exports = Duration;