src/charging-station/SharedLRUCache.ts

   1 import LRUCache from 'mnemonist/lru-map-with-delete';
   2
   3 import { Bootstrap } from '../internal';
   4 import type { ChargingStationConfiguration, ChargingStationTemplate } from '../types';
   5 import { Utils } from '../utils/Utils';
   6
   7 enum CacheType {
   8   CHARGING_STATION_TEMPLATE = 'chargingStationTemplate',
   9   CHARGING_STATION_CONFIGURATION = 'chargingStationConfiguration',
  10 }
  11
  12 type CacheableType = ChargingStationTemplate | ChargingStationConfiguration;
  13
  14 export class SharedLRUCache {
  15   private static instance: SharedLRUCache | null = null;
  16   private readonly lruCache: LRUCache<string, CacheableType>;
  17
  18   private constructor() {
  19     this.lruCache = new LRUCache<string, CacheableType>(
  20       Bootstrap.getInstance().numberOfChargingStationTemplates +
  21         Bootstrap.getInstance().numberOfChargingStations
  22     );
  23   }
  24
  25   public static getInstance(): SharedLRUCache {
  26     if (SharedLRUCache.instance === null) {
  27       SharedLRUCache.instance = new SharedLRUCache();
  28     }
  29     return SharedLRUCache.instance;
  30   }
  31
  32   public hasChargingStationConfiguration(chargingStationConfigurationHash: string): boolean {
  33     return this.has(this.getChargingStationConfigurationKey(chargingStationConfigurationHash));
  34   }
  35
  36   public setChargingStationConfiguration(
  37     chargingStationConfiguration: ChargingStationConfiguration
  38   ): void {
  39     if (this.isChargingStationConfigurationCacheable(chargingStationConfiguration)) {
  40       this.set(
  41         this.getChargingStationConfigurationKey(chargingStationConfiguration.configurationHash),
  42         chargingStationConfiguration
  43       );
  44     }
  45   }
  46
  47   public getChargingStationConfiguration(
  48     chargingStationConfigurationHash: string
  49   ): ChargingStationConfiguration {
  50     return this.get(
  51       this.getChargingStationConfigurationKey(chargingStationConfigurationHash)
  52     ) as ChargingStationConfiguration;
  53   }
  54
  55   public deleteChargingStationConfiguration(chargingStationConfigurationHash: string): void {
  56     this.delete(this.getChargingStationConfigurationKey(chargingStationConfigurationHash));
  57   }
  58
  59   public hasChargingStationTemplate(chargingStationTemplateHash: string): boolean {
  60     return this.has(this.getChargingStationTemplateKey(chargingStationTemplateHash));
  61   }
  62
  63   public setChargingStationTemplate(chargingStationTemplate: ChargingStationTemplate): void {
  64     this.set(
  65       this.getChargingStationTemplateKey(chargingStationTemplate.templateHash),
  66       chargingStationTemplate
  67     );
  68   }
  69
  70   public getChargingStationTemplate(chargingStationTemplateHash: string): ChargingStationTemplate {
  71     return this.get(
  72       this.getChargingStationTemplateKey(chargingStationTemplateHash)
  73     ) as ChargingStationTemplate;
  74   }
  75
  76   public deleteChargingStationTemplate(chargingStationTemplateHash: string): void {
  77     this.delete(this.getChargingStationTemplateKey(chargingStationTemplateHash));
  78   }
  79
  80   public clear(): void {
  81     this.lruCache.clear();
  82   }
  83
  84   private getChargingStationConfigurationKey(hash: string): string {
  85     return `${CacheType.CHARGING_STATION_CONFIGURATION}${hash}`;
  86   }
  87
  88   private getChargingStationTemplateKey(hash: string): string {
  89     return `${CacheType.CHARGING_STATION_TEMPLATE}${hash}`;
  90   }
  91
  92   private has(key: string): boolean {
  93     return this.lruCache.has(key);
  94   }
  95
  96   private get(key: string): CacheableType | undefined {
  97     return this.lruCache.get(key);
  98   }
  99
 100   private set(key: string, value: CacheableType): void {
 101     this.lruCache.set(key, value);
 102   }
 103
 104   private delete(key: string): void {
 105     this.lruCache.delete(key);
 106   }
 107
 108   private isChargingStationConfigurationCacheable(
 109     chargingStationConfiguration: ChargingStationConfiguration
 110   ): boolean {
 111     return (
 112       Utils.isNullOrUndefined(chargingStationConfiguration?.configurationKey) === false &&
 113       Utils.isNullOrUndefined(chargingStationConfiguration?.stationInfo) === false &&
 114       Utils.isNullOrUndefined(chargingStationConfiguration?.configurationHash) === false &&
 115       Utils.isNotEmptyArray(chargingStationConfiguration?.configurationKey) === true &&
 116       Utils.isEmptyObject(chargingStationConfiguration?.stationInfo) === false &&
 117       Utils.isNotEmptyString(chargingStationConfiguration?.configurationHash) === true
 118     );
 119   }
 120 }