unetjs 1.0.0 → 2.0.0

package/dist/unetjs.js

@@ -2,9 +2,9 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.unet = {}));
-}(this, (function (exports) { 'use strict';
+})(this, (function (exports) { 'use strict';
 
-  /* fjage.js v1.9.1-rc5 2021-07-07T04:07:53.061Z */
+  /* fjage.js v1.9.1-rc6 */
 
   /* global window self */
 
@@ -1275,6 +1275,8 @@
     'TRANSPORT': 'org.arl.unet.Services.TRANSPORT',
     'REMOTE': 'org.arl.unet.Services.REMOTE',
     'STATE_MANAGER': 'org.arl.unet.Services.STATE_MANAGER',
+    'DEVICE_INFO': 'org.arl.unet.Services.DEVICE_INFO',
+    'DOA': 'org.arl.unet.Services.DOA'
   };
 
   Object.assign(Services, UnetServices);
@@ -1303,100 +1305,361 @@
    */
   let UnetMessages = {
     // unet
-    'TestReportNtf'          : MessageClass('org.arl.unet.TestReportNtf'), 
-    'AbnormalTerminationNtf' : MessageClass('org.arl.unet.AbnormalTerminationNtf'), 
-    'CapabilityListRsp'      : MessageClass('org.arl.unet.CapabilityListRsp'), 
-    'CapabilityReq'          : MessageClass('org.arl.unet.CapabilityReq'), 
-    'ClearReq'               : MessageClass('org.arl.unet.ClearReq'), 
-    'DatagramCancelReq'      : MessageClass('org.arl.unet.DatagramCancelReq'), 
-    'DatagramDeliveryNtf'    : MessageClass('org.arl.unet.DatagramDeliveryNtf'), 
-    'DatagramFailureNtf'     : MessageClass('org.arl.unet.DatagramFailureNtf'), 
-    'DatagramNtf'            : MessageClass('org.arl.unet.DatagramNtf'), 
-    'DatagramProgressNtf'    : MessageClass('org.arl.unet.DatagramProgressNtf'), 
-    'DatagramReq'            : MessageClass('org.arl.unet.DatagramReq'), 
-    'ParamChangeNtf'         : MessageClass('org.arl.unet.ParamChangeNtf'), 
-    'RefuseRsp'              : MessageClass('org.arl.unet.RefuseRsp'), 
-    'FailureNtf'             : MessageClass('org.arl.unet.FailureNtf'), 
+    'TestReportNtf'          : MessageClass('org.arl.unet.TestReportNtf'),
+    'AbnormalTerminationNtf' : MessageClass('org.arl.unet.AbnormalTerminationNtf'),
+    'CapabilityListRsp'      : MessageClass('org.arl.unet.CapabilityListRsp'),
+    'CapabilityReq'          : MessageClass('org.arl.unet.CapabilityReq'),
+    'ClearReq'               : MessageClass('org.arl.unet.ClearReq'),
+    'DatagramCancelReq'      : MessageClass('org.arl.unet.DatagramCancelReq'),
+    'DatagramDeliveryNtf'    : MessageClass('org.arl.unet.DatagramDeliveryNtf'),
+    'DatagramFailureNtf'     : MessageClass('org.arl.unet.DatagramFailureNtf'),
+    'DatagramNtf'            : MessageClass('org.arl.unet.DatagramNtf'),
+    'DatagramProgressNtf'    : MessageClass('org.arl.unet.DatagramProgressNtf'),
+    'DatagramReq'            : MessageClass('org.arl.unet.DatagramReq'),
+    'ParamChangeNtf'         : MessageClass('org.arl.unet.ParamChangeNtf'),
+    'RefuseRsp'              : MessageClass('org.arl.unet.RefuseRsp'),
+    'FailureNtf'             : MessageClass('org.arl.unet.FailureNtf'),
 
     // net
-    'DatagramTraceReq'       : MessageClass('org.arl.unet.net.DatagramTraceReq'), 
-    'RouteDiscoveryReq'      : MessageClass('org.arl.unet.net.RouteDiscoveryReq'), 
-    'RouteTraceReq'          : MessageClass('org.arl.unet.net.RouteTraceReq'), 
-    'RouteDiscoveryNtf'      : MessageClass('org.arl.unet.net.RouteDiscoveryNtf'), 
-    'RouteTraceNtf'          : MessageClass('org.arl.unet.net.RouteTraceNtf'), 
+    'DatagramTraceReq'       : MessageClass('org.arl.unet.net.DatagramTraceReq'),
+    'RouteDiscoveryReq'      : MessageClass('org.arl.unet.net.RouteDiscoveryReq'),
+    'RouteTraceReq'          : MessageClass('org.arl.unet.net.RouteTraceReq'),
+    'RouteDiscoveryNtf'      : MessageClass('org.arl.unet.net.RouteDiscoveryNtf'),
+    'RouteTraceNtf'          : MessageClass('org.arl.unet.net.RouteTraceNtf'),
 
     // phy
-    'FecDecodeReq'           : MessageClass('org.arl.unet.phy.FecDecodeReq'), 
-    'RxJanusFrameNtf'        : MessageClass('org.arl.unet.phy.RxJanusFrameNtf'), 
-    'TxJanusFrameReq'        : MessageClass('org.arl.unet.phy.TxJanusFrameReq'), 
-    'BadFrameNtf'            : MessageClass('org.arl.unet.phy.BadFrameNtf'), 
+    'FecDecodeReq'           : MessageClass('org.arl.unet.phy.FecDecodeReq'),
+    'RxJanusFrameNtf'        : MessageClass('org.arl.unet.phy.RxJanusFrameNtf'),
+    'TxJanusFrameReq'        : MessageClass('org.arl.unet.phy.TxJanusFrameReq'),
+    'BadFrameNtf'            : MessageClass('org.arl.unet.phy.BadFrameNtf'),
     'BadRangeNtf'            : MessageClass('org.arl.unet.phy.BadRangeNtf'),
-    'ClearSyncReq'           : MessageClass('org.arl.unet.phy.ClearSyncReq'), 
-    'CollisionNtf'           : MessageClass('org.arl.unet.phy.CollisionNtf'), 
-    'RxFrameNtf'             : MessageClass('org.arl.unet.phy.RxFrameNtf', DatagramNtf$1), 
-    'RxFrameStartNtf'        : MessageClass('org.arl.unet.phy.RxFrameStartNtf'), 
-    'SyncInfoReq'            : MessageClass('org.arl.unet.phy.SyncInfoReq'), 
-    'SyncInfoRsp'            : MessageClass('org.arl.unet.phy.SyncInfoRsp'), 
-    'TxFrameNtf'             : MessageClass('org.arl.unet.phy.TxFrameNtf'), 
-    'TxFrameReq'             : MessageClass('org.arl.unet.phy.TxFrameReq', DatagramReq$1), 
-    'TxFrameStartNtf'        : MessageClass('org.arl.unet.phy.TxFrameStartNtf'), 
-    'TxRawFrameReq'          : MessageClass('org.arl.unet.phy.TxRawFrameReq'), 
+    'ClearSyncReq'           : MessageClass('org.arl.unet.phy.ClearSyncReq'),
+    'CollisionNtf'           : MessageClass('org.arl.unet.phy.CollisionNtf'),
+    'RxFrameNtf'             : MessageClass('org.arl.unet.phy.RxFrameNtf', DatagramNtf$1),
+    'RxFrameStartNtf'        : MessageClass('org.arl.unet.phy.RxFrameStartNtf'),
+    'SyncInfoReq'            : MessageClass('org.arl.unet.phy.SyncInfoReq'),
+    'SyncInfoRsp'            : MessageClass('org.arl.unet.phy.SyncInfoRsp'),
+    'TxFrameNtf'             : MessageClass('org.arl.unet.phy.TxFrameNtf'),
+    'TxFrameReq'             : MessageClass('org.arl.unet.phy.TxFrameReq', DatagramReq$1),
+    'TxFrameStartNtf'        : MessageClass('org.arl.unet.phy.TxFrameStartNtf'),
+    'TxRawFrameReq'          : MessageClass('org.arl.unet.phy.TxRawFrameReq'),
 
     // addr
-    'AddressAllocReq'        : MessageClass('org.arl.unet.addr.AddressAllocReq'), 
-    'AddressAllocRsp'        : MessageClass('org.arl.unet.addr.AddressAllocRsp'), 
-    'AddressResolutionReq'   : MessageClass('org.arl.unet.addr.AddressResolutionReq'), 
-    'AddressResolutionRsp'   : MessageClass('org.arl.unet.addr.AddressResolutionRsp'), 
+    'AddressAllocReq'        : MessageClass('org.arl.unet.addr.AddressAllocReq'),
+    'AddressAllocRsp'        : MessageClass('org.arl.unet.addr.AddressAllocRsp'),
+    'AddressResolutionReq'   : MessageClass('org.arl.unet.addr.AddressResolutionReq'),
+    'AddressResolutionRsp'   : MessageClass('org.arl.unet.addr.AddressResolutionRsp'),
 
     // bb
-    'BasebandSignal'         : MessageClass('org.arl.unet.bb.BasebandSignal'), 
-    'RecordBasebandSignalReq' : MessageClass('org.arl.unet.bb.RecordBasebandSignalReq'), 
-    'RxBasebandSignalNtf'    : MessageClass('org.arl.unet.bb.RxBasebandSignalNtf', BasebandSignal), 
-    'TxBasebandSignalReq'    : MessageClass('org.arl.unet.bb.TxBasebandSignalReq', BasebandSignal), 
+    'BasebandSignal'         : MessageClass('org.arl.unet.bb.BasebandSignal'),
+    'RecordBasebandSignalReq' : MessageClass('org.arl.unet.bb.RecordBasebandSignalReq'),
+    'RxBasebandSignalNtf'    : MessageClass('org.arl.unet.bb.RxBasebandSignalNtf', BasebandSignal),
+    'TxBasebandSignalReq'    : MessageClass('org.arl.unet.bb.TxBasebandSignalReq', BasebandSignal),
 
     // link
-    'LinkStatusNtf'          : MessageClass('org.arl.unet.link.LinkStatusNtf'), 
+    'LinkStatusNtf'          : MessageClass('org.arl.unet.link.LinkStatusNtf'),
 
     // localization
-    'RangeNtf'               : MessageClass('org.arl.unet.localization.RangeNtf'), 
-    'RangeReq'               : MessageClass('org.arl.unet.localization.RangeReq'), 
-    'BeaconReq'              : MessageClass('org.arl.unet.localization.BeaconReq'), 
-    'RespondReq'             : MessageClass('org.arl.unet.localization.RespondReq'), 
-    'InterrogationNtf'       : MessageClass('org.arl.unet.localization.InterrogationNtf'), 
+    'RangeNtf'               : MessageClass('org.arl.unet.localization.RangeNtf'),
+    'RangeReq'               : MessageClass('org.arl.unet.localization.RangeReq'),
+    'BeaconReq'              : MessageClass('org.arl.unet.localization.BeaconReq'),
+    'RespondReq'             : MessageClass('org.arl.unet.localization.RespondReq'),
+    'InterrogationNtf'       : MessageClass('org.arl.unet.localization.InterrogationNtf'),
 
 
     // mac
-    'ReservationAcceptReq'   : MessageClass('org.arl.unet.mac.ReservationAcceptReq'), 
-    'ReservationCancelReq'   : MessageClass('org.arl.unet.mac.ReservationCancelReq'), 
-    'ReservationReq'         : MessageClass('org.arl.unet.mac.ReservationReq'), 
-    'ReservationRsp'         : MessageClass('org.arl.unet.mac.ReservationRsp'), 
-    'ReservationStatusNtf'   : MessageClass('org.arl.unet.mac.ReservationStatusNtf'), 
-    'RxAckNtf'               : MessageClass('org.arl.unet.mac.RxAckNtf'), 
-    'TxAckReq'               : MessageClass('org.arl.unet.mac.TxAckReq'), 
+    'ReservationAcceptReq'   : MessageClass('org.arl.unet.mac.ReservationAcceptReq'),
+    'ReservationCancelReq'   : MessageClass('org.arl.unet.mac.ReservationCancelReq'),
+    'ReservationReq'         : MessageClass('org.arl.unet.mac.ReservationReq'),
+    'ReservationRsp'         : MessageClass('org.arl.unet.mac.ReservationRsp'),
+    'ReservationStatusNtf'   : MessageClass('org.arl.unet.mac.ReservationStatusNtf'),
+    'RxAckNtf'               : MessageClass('org.arl.unet.mac.RxAckNtf'),
+    'TxAckReq'               : MessageClass('org.arl.unet.mac.TxAckReq'),
 
 
     // remote
-    'RemoteExecReq'          : MessageClass('org.arl.unet.remote.RemoteExecReq'), 
-    'RemoteFailureNtf'       : MessageClass('org.arl.unet.remote.RemoteFailureNtf'), 
-    'RemoteFileGetReq'       : MessageClass('org.arl.unet.remote.RemoteFileGetReq'), 
-    'RemoteFileNtf'          : MessageClass('org.arl.unet.remote.RemoteFileNtf'), 
-    'RemoteFilePutReq'       : MessageClass('org.arl.unet.remote.RemoteFilePutReq'), 
-    'RemoteSuccessNtf'       : MessageClass('org.arl.unet.remote.RemoteSuccessNtf'), 
-    'RemoteTextNtf'          : MessageClass('org.arl.unet.remote.RemoteTextNtf'), 
-    'RemoteTextReq'          : MessageClass('org.arl.unet.remote.RemoteTextReq'), 
+    'RemoteExecReq'          : MessageClass('org.arl.unet.remote.RemoteExecReq'),
+    'RemoteFailureNtf'       : MessageClass('org.arl.unet.remote.RemoteFailureNtf'),
+    'RemoteFileGetReq'       : MessageClass('org.arl.unet.remote.RemoteFileGetReq'),
+    'RemoteFileNtf'          : MessageClass('org.arl.unet.remote.RemoteFileNtf'),
+    'RemoteFilePutReq'       : MessageClass('org.arl.unet.remote.RemoteFilePutReq'),
+    'RemoteSuccessNtf'       : MessageClass('org.arl.unet.remote.RemoteSuccessNtf'),
+    'RemoteTextNtf'          : MessageClass('org.arl.unet.remote.RemoteTextNtf'),
+    'RemoteTextReq'          : MessageClass('org.arl.unet.remote.RemoteTextReq'),
 
     // scheduler
-    'AddScheduledSleepReq'   : MessageClass('org.arl.unet.scheduler.AddScheduledSleepReq'), 
-    'GetSleepScheduleReq'    : MessageClass('org.arl.unet.scheduler.GetSleepScheduleReq'), 
-    'RemoveScheduledSleepReq' : MessageClass('org.arl.unet.scheduler.RemoveScheduledSleepReq'), 
-    'SleepScheduleRsp'       : MessageClass('org.arl.unet.scheduler.SleepScheduleRsp'), 
-    'WakeFromSleepNtf'       : MessageClass('org.arl.unet.scheduler.WakeFromSleepNtf'), 
+    'AddScheduledSleepReq'   : MessageClass('org.arl.unet.scheduler.AddScheduledSleepReq'),
+    'GetSleepScheduleReq'    : MessageClass('org.arl.unet.scheduler.GetSleepScheduleReq'),
+    'RemoveScheduledSleepReq' : MessageClass('org.arl.unet.scheduler.RemoveScheduledSleepReq'),
+    'SleepScheduleRsp'       : MessageClass('org.arl.unet.scheduler.SleepScheduleRsp'),
+    'WakeFromSleepNtf'       : MessageClass('org.arl.unet.scheduler.WakeFromSleepNtf'),
 
     // state
-    'ClearStateReq'          : MessageClass('org.arl.unet.state.ClearStateReq'), 
+    'ClearStateReq'          : MessageClass('org.arl.unet.state.ClearStateReq'),
     'SaveStateReq'           : MessageClass('org.arl.unet.state.SaveStateReq')
   };
 
+  /**
+    * Convert coordinates from a local coordinates to GPS coordinate
+    * @param {Array} origin - Local coordinate system's origin as `[latitude, longitude]`
+    * @param {Number} x - X coordinate of the local coordinate to be converted
+    * @param {Number} y - Y coordinate of the local coordinate to be converted
+    * @returns {Array} - GPS coordinates (in decimal degrees) as `[latitude, longitude]`
+    */
+
+  function toGps(origin, x, y) {
+    let coords = [] ;
+    let [xScale,yScale] = _initConv(origin[0]);
+    coords[1] = x/xScale + origin[1];
+    coords[0] = y/yScale + origin[0];
+    return coords;
+  }
+
+  /**
+    * Convert coordinates from a GPS coordinates to local coordinate
+    * @param {Array} origin - Local coordinate system's origin as `[latitude, longitude]`
+    * @param {Number} lat - Latitude of the GPS coordinate to be converted
+    * @param {Number} lon - Longitude of the GPS coordinate to be converted
+    * @returns {Array} - GPS coordinates (in decimal degrees) as `[latitude, longitude]`
+    */
+  function toLocal(origin, lat, lon) {
+    let pos = [];
+    let [xScale,yScale] = _initConv(origin[0]);
+    pos[0] = (lon-origin[1]) * xScale;
+    pos[1] = (lat-origin[0]) * yScale;
+    return pos;
+  }
+
+  function _initConv(lat){
+    let rlat = lat * Math.PI/180;
+    let yScale = 111132.92 - 559.82*Math.cos(2*rlat) + 1.175*Math.cos(4*rlat) - 0.0023*Math.cos(6*rlat);
+    let xScale = 111412.84*Math.cos(rlat) - 93.5*Math.cos(3*rlat) + 0.118*Math.cos(5*rlat);
+    return [xScale, yScale];
+  }
+
+  /**
+   * A message which requests the transmission of the datagram from the Unet
+   *
+   * @typedef {Message} DatagramReq
+   * @property {number[]} data - data as an Array of bytes
+   * @property {number} from - from/source node address
+   * @property {number} to - to/destination node address
+   * @property {number} protocol - protocol number to be used to send this Datagram
+   * @property {boolean} reliability - true if Datagram should be reliable, false if unreliable
+   * @property {number} ttl - time-to-live for the datagram. Time-to-live is advisory, and an agent may choose it ignore it
+   */
+
+  /**
+   * Notification of received datagram message received by the Unet node.
+   *
+   * @typedef {Message} DatagramNtf
+   * @property {number[]} data - data as an Array of bytes
+   * @property {number} from - from/source node address
+   * @property {number} to - to/destination node address
+   * @property {number} protocol - protocol number to be used to send this Datagram
+   * @property {number} ttl - time-to-live for the datagram. Time-to-live is advisory, and an agent may choose it ignore it
+   */
+
+  /**
+   * An identifier for an agent or a topic.
+   * @external AgentID
+   * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+   */
+
+  /**
+   * Services supported by fjage agents.
+   * @external Services
+   * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+   */
+
+  /**
+   *  An action represented by a message.
+   * @external Performative
+   * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+   */
+
+  /**
+   * Function to creates a unqualified message class based on a fully qualified name.
+   * @external MessageClass
+   * @see {@link https://org-arl.github.io/fjage/jsdoc/|fjåge.js Documentation}
+   */
+
+  /**
+   * A caching CachingAgentID which caches Agent parameters locally.
+   *
+   * @class
+   * @extends AgentID
+   * @param {string | AgentID} name - name of the agent or an AgentID to copy
+   * @param {boolean} topic - name of topic
+   * @param {Gateway} owner - Gateway owner for this AgentID
+   * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+   *
+  */
+  class CachingAgentID extends AgentID {
+
+    constructor(name, topic, owner, greedy=true) {
+      if (name instanceof AgentID) {
+        super(name.getName(), name.topic, name.owner);
+      } else {
+        super(name, topic, owner);
+      }
+      this.greedy = greedy;
+      this.cache = {};
+    }
+
+    /**
+     * Sets parameter(s) on the Agent referred to by this AgentID, and caches the parameter(s).
+     *
+     * @param {(string|string[])} params - parameters name(s) to be set
+     * @param {(Object|Object[])} values - parameters value(s) to be set
+     * @param {number} [index=-1] - index of parameter(s) to be set
+     * @param {number} [timeout=5000] - timeout for the response
+     * @returns {Promise<(Object|Object[])>} - a promise which returns the new value(s) of the parameters
+     */
+    async set(params, values, index=-1, timeout=5000) {
+      let s = await super.set(params, values, index, timeout);
+      this._updateCache(params, s, index);
+    }
+
+    /**
+     * Gets parameter(s) on the Agent referred to by this AgentID, getting them from the cache if possible.
+     *
+     * @param {(string|string[])} params - parameters name(s) to be fetched
+     * @param {number} [index=-1] - index of parameter(s) to be fetched
+     * @param {number} [timeout=5000] - timeout for the response
+     * @param {number} [maxage=5000] - maximum age of the cached result to retreive
+     * @returns {Promise<(Object|Object[])>} - a promise which returns the value(s) of the parameters
+     */
+    async get(params, index=-1, timeout=5000, maxage=5000) {
+      if (this._isCached(params, index, maxage)) return this._getCache(params, index);
+      if (this.greedy && !(Array.isArray(params) && params.includes('name')) && params != 'name') {
+        let rsp = await super.get(null, index, timeout);
+        this._updateCache(null, rsp, index);
+        if (Array.isArray(params)) {
+          return params.map(p => {
+            let f = Object.keys(rsp).find(rv => this._toNamed(rv) === p);
+            return f ? rsp[f] : null;
+          });
+        } else {
+          let f = Object.keys(rsp).find(rv => this._toNamed(rv) === params);
+          return f ? rsp[f] : null;
+        }
+      } else {
+        let r = await super.get(params, index, timeout);
+        this._updateCache(params, r, index);
+        return r;
+      }
+    }
+
+    _updateCache(params, vals, index) {
+      if (vals == null || Array.isArray(vals) && vals.every(v => v == null)) return;
+      if (params == null) {
+        params = Object.keys(vals);
+        vals = Object.values(vals);
+      } else if (!Array.isArray(params)) params = [params];
+      if (!Array.isArray(vals)) vals = [vals];
+      params = params.map(this._toNamed);
+      if (this.cache[index.toString()] === undefined) this.cache[index.toString()] = {};
+      let c = this.cache[index.toString()];
+      for (let i = 0; i < params.length; i++) {
+        if (c[params[i]] === undefined) c[params[i]] = {};
+        c[params[i]].value = vals[i];
+        c[params[i]].ctime = Date.now();
+      }
+    }
+
+    _isCached(params, index, maxage) {
+      if (maxage <= 0) return false;
+      if (params == null) return false;
+      let c = this.cache[index.toString()];
+      if (!c) {
+        return false;
+      }
+      if (!Array.isArray(params)) params = [params];
+      const rv = params.every(p => {
+        p = this._toNamed(p);
+        return (p in c) && (Date.now() - c[p].ctime <= maxage);
+      });
+      return rv;
+    }
+
+    _getCache(params, index) {
+      let c = this.cache[index.toString()];
+      if (!c) return null;
+      if (!Array.isArray(params)){
+        if (params in c) return c[params].value;
+        return null;
+      }else {
+        return params.map(p => p in c ? c[p].value : null);
+      }
+    }
+
+    _toNamed(param) {
+      const idx = param.lastIndexOf('.');
+      if (idx < 0) return param;
+      else return param.slice(idx+1);
+    }
+
+  }
+
+
+  class CachingGateway extends Gateway{
+
+    /**
+     * Get an AgentID for a given agent name.
+     *
+     * @param {string} name - name of agent
+     * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+     * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+     * @returns {AgentID|CachingAgentID} - AgentID for the given name
+     */
+    agent(name, caching=true, greedy=true) {
+      const aid = super.agent(name);
+      return caching ? new CachingAgentID(aid, null, null, greedy) : aid;
+    }
+
+    /**
+     * Returns an object representing the named topic.
+     *
+     * @param {string|AgentID} topic - name of the topic or AgentID
+     * @param {string} topic2 - name of the topic if the topic param is an AgentID
+     * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+     * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+     * @returns {AgentID|CachingAgentID} - object representing the topic
+     */
+    topic(topic, topic2, caching=true, greedy=true) {
+      const aid = super.topic(topic, topic2);
+      return caching ? new CachingAgentID(aid, null, null, greedy) : aid;
+    }
+
+    /**
+     * Finds an agent that provides a named service. If multiple agents are registered
+     * to provide a given service, any of the agents' id may be returned.
+     *
+     * @param {string} service - the named service of interest
+     * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+     * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+     * @returns {Promise<?AgentID|CachingAgentID>} - a promise which returns an agent id for an agent that provides the service when resolved
+     */
+    async agentForService(service, caching=true, greedy=true) {
+      const aid = await super.agentForService(service);
+      return caching ? new CachingAgentID(aid, null, null, greedy) : aid;
+    }
+
+    /**
+     * Finds all agents that provides a named service.
+     *
+     * @param {string} service - the named service of interest
+     * @param {Boolean} [caching=true] - if the AgentID should cache parameters
+     * @param {Boolean} [greedy=true] - greedily fetches and caches all parameters if this Agent
+     * @returns {Promise<?AgentID|CachingAgentID[]>} - a promise which returns an array of all agent ids that provides the service when resolved
+     */
+    async agentsForService(service, caching=true, greedy=true) {
+      const aids = await super.agentsForService(service);
+      return caching ? aids.map(a => new CachingAgentID(a, null, null, greedy)) : aids;
+    }
+  }
+
   const REQUEST_TIMEOUT = 1000;
 
   const AddressResolutionReq = UnetMessages.AddressResolutionReq;
@@ -1405,26 +1668,26 @@
   const RxFrameNtf = UnetMessages.RxFrameNtf;
 
   /**
-   * Creates a new UnetSocket to connect to a running Unet instance. This constructor returns a 
-   * {@link Promise} instead of the constructed UnetSocket object. Use `await` or `.then()` to get 
-   * a reference to the UnetSocket object. Based on if this is run in a Browser or Node.js, 
+   * Creates a new UnetSocket to connect to a running Unet instance. This constructor returns a
+   * {@link Promise} instead of the constructed UnetSocket object. Use `await` or `.then()` to get
+   * a reference to the UnetSocket object. Based on if this is run in a Browser or Node.js,
    * it will internally connect over WebSockets or TCP respectively.
    *
-   * 
+   *
    * @class UnetSocket
    * @param {string} [hostname] - hostname/ip address of the master container to connect to
    * @param {number} [port] - port number of the master container to connect to
    * @param {string} [path='']  - path of the master container to connect to (for WebSockets)
    * @returns {Promise<UnetSocket>} - Promise which resolves to the UnetSocket object being constructed
-   * 
+   *
    * @example
    * let socket = await new UnetSocket('localhost', 8081, '/ws/');
    */
   class UnetSocket {
 
-    constructor(hostname, port, path='') { 
+    constructor(hostname, port, path='') {
       return (async () => {
-        this.gw = new Gateway({
+        this.gw = new CachingGateway({
           hostname : hostname,
           port : port,
           path : path
@@ -1453,13 +1716,13 @@
      * Checks if a socket is closed.
      * @returns {boolean} - true if closed, false if open
      */
-    isClosed() { 
+    isClosed() {
       return this.gw == null;
     }
 
     /**
      * Binds a socket to listen to a specific protocol datagrams.
-     * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are reserved protocols 
+     * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are reserved protocols
      * and cannot be bound. Unbound sockets listen to all unreserved
      * @param {Protocol} protocol - protocol number to listen for
      * @returns {boolean} - true on success, false on failure
@@ -1471,9 +1734,9 @@
       }
       return false;
     }
-    
+
     /**
-     * Unbinds a socket so that it listens to all unreserved protocols. 
+     * Unbinds a socket so that it listens to all unreserved protocols.
      * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are considered reserved.
      * @returns {void}
      */
@@ -1486,13 +1749,13 @@
     isBound() { return this.localProtocol >= 0;}
 
     /**
-     * Sets the default destination address and destination protocol number for datagrams sent 
-     * using this socket. The defaults can be overridden for specific send() calls. 
-     * The default protcol number when a socket is opened is Protcol.DATA. 
-     * The default node address is undefined. 
-     * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are considered reserved, 
+     * Sets the default destination address and destination protocol number for datagrams sent
+     * using this socket. The defaults can be overridden for specific send() calls.
+     * The default protcol number when a socket is opened is Protcol.DATA.
+     * The default node address is undefined.
+     * Protocol numbers between Protocol.DATA+1 to Protocol.USER-1 are considered reserved,
      * and cannot be used for sending datagrams using the socket.
-     * 
+     *
      * @param {number} to - default destination node address
      * @param {Protocol} protocol - default protocol number
      * @returns {boolean} - true on success, false on failure
@@ -1507,11 +1770,11 @@
     }
 
     /**
-     * Resets the default destination address to undefined, and the default protocol number 
+     * Resets the default destination address to undefined, and the default protocol number
      * to Protocol.DATA.
      * @returns {void}
      */
-    disconnect() { 
+    disconnect() {
       this.remoteAddress = -1;
       this.remoteProtocol = 0;
     }
@@ -1526,7 +1789,7 @@
      * Gets the local node address of the Unet node connected to.
      * @returns {Promise<int>} - local node address, or -1 on error
      */
-    async getLocalAddress() { 
+    async getLocalAddress() {
       if (this.gw == null) return -1;
       const nodeinfo = await this.gw.agentForService(Services.NODE_INFO);
       if (nodeinfo == null) return -1;
@@ -1553,14 +1816,14 @@
     getRemoteProtocol() { return this.remoteProtocol; }
 
     /**
-     * Sets the timeout for datagram reception. A timeout of 0 means the 
-     * {@link UnetSocket#receive|receive method} will check any appropriate 
+     * Sets the timeout for datagram reception. A timeout of 0 means the
+     * {@link UnetSocket#receive|receive method} will check any appropriate
      * Datagram has already been received (and is cached) else return immediately.
-     * 
+     *
      * @param {number} ms - timeout in milliseconds
      * @returns {void}
      */
-    setTimeout(ms) { 
+    setTimeout(ms) {
       if (ms < 0) ms = 0;
       this.timeout = ms;
     }
@@ -1609,12 +1872,12 @@
     }
 
     /**
-     * Receives a datagram sent to the local node and the bound protocol number. If the socket is unbound, 
+     * Receives a datagram sent to the local node and the bound protocol number. If the socket is unbound,
      * then datagrams with all unreserved protocols are received. Any broadcast datagrams are also received.
-     * 
+     *
      * @returns {Promise<?DatagramNtf>} - datagram received by the socket
      */
-    async receive() { 
+    async receive() {
       if (this.gw == null) return null;
       return await this.gw.receive(msg => {
         if (msg.__clazz__ != DatagramNtf.__clazz__ && msg.__clazz__ != RxFrameNtf.__clazz__ ) return false;
@@ -1635,31 +1898,34 @@
     /**
      * Gets an AgentID providing a specified service for low-level access to UnetStack
      * @param {string} svc - the named service of interest
+     * @param {Boolean} caching - if the AgentID should cache parameters
      * @returns {Promise<?AgentID>} - a promise which returns an {@link AgentID} that provides the service when resolved
      */
-    async agentForService(svc) {
+    async agentForService(svc, caching=true) {
       if (this.gw == null) return null;
-      return await this.gw.agentForService(svc);
+      return await this.gw.agentForService(svc, caching);
     }
 
     /**
-     * 
+     *
      * @param {string} svc - the named service of interest
+     * @param {Boolean} caching - if the AgentID should cache parameters
      * @returns {Promise<AgentID[]>} - a promise which returns an array of {@link AgentID|AgentIDs} that provides the service when resolved
      */
-    async agentsForService(svc) {
+    async agentsForService(svc, caching=true) {
       if (this.gw == null) return null;
-      return await this.gw.agentsForService(svc);
+      return await this.gw.agentsForService(svc, caching``);
     }
 
     /**
      * Gets a named AgentID for low-level access to UnetStack.
      * @param {string} name - name of agent
+     * @param {Boolean} caching - if the AgentID should cache parameters
      * @returns {AgentID} - AgentID for the given name
      */
-    agent(name) {
+    agent(name, caching=true) {
       if (this.gw == null) return null;
-      return this.gw.agent(name);
+      return this.gw.agent(name, caching);
     }
 
     /**
@@ -1667,7 +1933,7 @@
      * @param {string} nodeName - name of the node to resolve
      * @returns {Promise<?number>} - address of the node, or null if unable to resolve
      */
-    async host(nodeName) { 
+    async host(nodeName) {
       const arp = await this.agentForService(Services.ADDRESS_RESOLUTION);
       if (arp == null) return null;
       const req = new AddressResolutionReq(nodeName);
@@ -1680,7 +1946,8 @@
   }
 
   exports.AgentID = AgentID;
-  exports.Gateway = Gateway;
+  exports.CachingAgentID = CachingAgentID;
+  exports.Gateway = CachingGateway;
   exports.Message = Message;
   exports.MessageClass = MessageClass;
   exports.Performative = Performative;
@@ -1688,6 +1955,8 @@
   exports.Services = Services;
   exports.UnetMessages = UnetMessages;
   exports.UnetSocket = UnetSocket;
+  exports.toGps = toGps;
+  exports.toLocal = toLocal;
 
-})));
+}));
 //# sourceMappingURL=unetjs.js.map