@openhps/core/dist/esm/service/MemoryDataService.js

Open Hybrid Positioning System - Core component

import { DataServiceDriver } from './DataServiceDriver';
import { MemoryQueryEvaluator } from './MemoryQueryEvaluator';
export class MemoryDataService extends DataServiceDriver {
  constructor(dataType, options) {
    super(dataType, options);
    this._data = new Map();
  }
  findByUID(uid) {
    return new Promise((resolve, reject) => {
      if (this._data.has(uid)) {
        resolve(this.options.deserialize(this._data.get(uid)));
      } else {
        reject(`${this.dataType.name} with identifier #${uid} not found!`);
      }
    });
  }
  findOne(query, options = {}) {
    return new Promise((resolve, reject) => {
      this.findAll(query, {
        limit: 1,
        sort: options.sort
      }).then(results => {
        if (results.length > 0) {
          return resolve(results[0]);
        } else {
          resolve(undefined);
        }
      }).catch(reject);
    });
  }
  findAll(query, options = {}) {
    return new Promise(resolve => {
      options.limit = options.limit || this._data.size;
      let data = [];
      this._data.forEach(object => {
        if (MemoryQueryEvaluator.evaluate(object, query)) {
          data.push(object);
          if (!options.sort && data.length >= options.limit) {
            return;
          }
        }
      });
      if (options.sort) {
        data = data.sort((a, b) => options.sort.map(s => {
          const res1 = MemoryQueryEvaluator.getValueFromPath(s[1] > 0 ? a : b, s[0])[1];
          const res2 = MemoryQueryEvaluator.getValueFromPath(s[1] > 0 ? b : a, s[0])[1];
          if (typeof res1 === 'number') {
            return res1 - res2;
          } else if (typeof res1 === 'string') {
            return res1.localeCompare(res2);
          } else {
            return 0;
          }
        }).reduce((a, b) => a + b)).slice(0, options.limit);
      }
      data = data.map(this.options.deserialize);
      resolve(data);
    });
  }
  insert(id, object) {
    return new Promise(resolve => {
      if (id && object) {
        this._data.set(id, this.options.serialize(object));
        resolve(object);
      } else {
        resolve(undefined);
      }
    });
  }
  delete(id) {
    return new Promise((resolve, reject) => {
      if (this._data.has(id)) {
        this._data.delete(id);
        resolve();
      } else {
        reject(`Unable to delete! ${this.dataType.name} with identifier #${id} not found!`);
      }
    });
  }
  count(filter) {
    return new Promise(resolve => {
      if (filter === undefined) {
        resolve(this._data.size);
      } else {
        let count = 0;
        for (const [, value] of this._data) {
          if (MemoryQueryEvaluator.evaluate(value, filter)) {
            count++;
          }
        }
        resolve(count);
      }
    });
  }
  deleteAll(filter) {
    return new Promise(resolve => {
      if (filter === undefined) {
        this._data = new Map();
      } else {
        for (const [key, value] of this._data) {
          if (MemoryQueryEvaluator.evaluate(value, filter)) {
            this.delete(key);
          }
        }
      }
      resolve();
    });
  }
}