@armyc2.c5isr.renderer/mil-sym-ts-web 2.2.0

package/src/main/ts/armyc2/c5isr/renderer/utilities/LRUCache.ts

@@ -0,0 +1,127 @@
+import { type int } from "../../graphics2d/BasicTypes";
+import { ImageInfo } from "../../renderer/utilities/ImageInfo"
+import { LRUEntry } from "../../renderer/utilities/LRUEntry"
+
+
+
+/**
+ * Modified LRUCache implementation from: https://techblogstation.com/java/lru-cache-implementation-in-java/
+ * and
+ * https://www.baeldung.com/java-lru-cache
+ */
+
+
+//The class for LRU Cache storage and its operations
+export class LRUCache {
+
+        // Variable to store the least recently used element
+        private lruElement: LRUEntry;
+
+        // Variable to store the most recently used element
+        private mruElement: LRUEntry;
+
+        private container: Map<string, LRUEntry>;
+        private capacity: int = 0;
+        private currentSize: int = 0;
+
+        //private readonly lock: java.util.concurrent.locks.ReentrantReadWriteLock = new java.util.concurrent.locks.ReentrantReadWriteLock();
+
+        // Constructor for setting the values in instance variables
+        public constructor(capacity: int) {
+                this.capacity = capacity;
+                this.currentSize = 0;
+                this.lruElement = new LRUEntry(null, null, null, null);
+                this.mruElement = this.lruElement;
+                this.container = new Map<string, LRUEntry>();
+        }
+
+        // The get method to perform the retrieve operations on data
+        public get(key: string): ImageInfo | null {
+                //this.lock.readLock().lock();
+                try {
+                        let tempLRUEntry: LRUEntry = this.container.get(key);
+                        if (tempLRUEntry == null) {
+                                return null;
+                        }
+                        // In case the MRU leave the list as it is :
+                        else {
+                                if (tempLRUEntry.key === this.mruElement.key) {
+                                        return this.mruElement.value;
+                                }
+                        }
+
+
+                        // Getting the Next and Previous Nodes
+                        let nextLRUEntry: LRUEntry = tempLRUEntry.next;
+                        let prevLRUEntry: LRUEntry = tempLRUEntry.prev;
+
+                        // If LRU is updated at the left-most
+                        if (tempLRUEntry.key === this.lruElement.key) {
+                                nextLRUEntry.prev = null;
+                                this.lruElement = nextLRUEntry;
+                        }
+
+                        // In case we are in the middle, we are required to update the items before and
+                        // after our item
+                        else {
+                                if (tempLRUEntry.key !== this.mruElement.key) {
+                                        prevLRUEntry.next = nextLRUEntry;
+                                        nextLRUEntry.prev = prevLRUEntry;
+                                }
+                        }
+
+
+                        // And here we are finally moving our item to MRU
+                        tempLRUEntry.prev = this.mruElement;
+                        this.mruElement.next = tempLRUEntry;
+                        this.mruElement = tempLRUEntry;
+                        this.mruElement.next = null;
+
+                        return tempLRUEntry.value;
+                }
+                finally {
+                       // this.lock.readLock().unlock();
+                }
+
+        }
+
+        // The put method to perform the insert operations on cache
+
+        public put(key: string, value: ImageInfo): void {
+                //this.lock.writeLock().lock();
+                try {
+                        if (this.container.has(key)) {
+                                return;
+                        }
+
+                        // Inserting the new Node at the right-most end position of the linked-list
+                        let myLRUEntry: LRUEntry = new LRUEntry(this.mruElement, null, key, value);
+                        this.mruElement.next = myLRUEntry;
+                        this.container.set(key, myLRUEntry);
+                        this.mruElement = myLRUEntry;
+
+                        // Deleting the entry of position left-most of LRU cache and also updating the
+                        // LRU pointer
+                        if (this.currentSize === this.capacity) {
+                                this.container.delete(this.lruElement.key);
+                                this.lruElement = this.lruElement.next;
+                                this.lruElement.prev = null;
+                        }
+
+                        // Updating the size of container for the firstly added entry and updating the
+                        // LRU pointer
+                        else {
+                                if (this.currentSize < this.capacity) {
+                                        if (this.currentSize === 0) {
+                                                this.lruElement = myLRUEntry;
+                                        }
+                                        this.currentSize++;
+                                }
+                        }
+
+                }
+                finally {
+                        //this.lock.writeLock().unlock();
+                }
+        }
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/LRUEntry.ts

@@ -0,0 +1,18 @@
+import { ImageInfo } from "../../renderer/utilities/ImageInfo"
+
+//The Node class for doubly linked list
+export class LRUEntry {
+
+    public key: string;
+    public value: ImageInfo;
+    public next: LRUEntry;
+    public prev: LRUEntry;
+
+    public constructor(prev: LRUEntry, next: LRUEntry, key: string, value: ImageInfo) {
+        this.prev = prev;
+        this.next = next;
+        this.key = key;
+        this.value = value;
+    }
+
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/LogLevel.ts

@@ -0,0 +1,111 @@
+/**
+ * Port of java.util.logging.Level class
+ */
+export class LogLevel {
+    /**
+     * OFF is a special level that can be used to turn off logging.
+     * This level is initialized to <CODE>Integer.MAX_VALUE</CODE>.
+     */
+    public static OFF = new LogLevel("OFF", Number.MAX_VALUE);
+
+    /**
+     * SEVERE is a message level indicating a serious failure.
+     * <p>
+     * In general SEVERE messages should describe events that are
+     * of considerable importance and which will prevent normal
+     * program execution.   They should be reasonably intelligible
+     * to end users and to system administrators.
+     * This level is initialized to <CODE>1000</CODE>.
+     */
+    public static SEVERE = new LogLevel("SEVERE", 1000);
+
+    /**
+     * WARNING is a message level indicating a potential problem.
+     * <p>
+     * In general WARNING messages should describe events that will
+     * be of interest to end users or system managers, or which
+     * indicate potential problems.
+     * This level is initialized to <CODE>900</CODE>.
+     */
+    public static WARNING = new LogLevel("WARNING", 900);
+
+    /**
+     * INFO is a message level for informational messages.
+     * <p>
+     * Typically INFO messages will be written to the console
+     * or its equivalent.  So the INFO level should only be
+     * used for reasonably significant messages that will
+     * make sense to end users and system administrators.
+     * This level is initialized to <CODE>800</CODE>.
+     */
+    public static INFO = new LogLevel("INFO", 800);
+
+    /**
+     * CONFIG is a message level for static configuration messages.
+     * <p>
+     * CONFIG messages are intended to provide a variety of static
+     * configuration information, to assist in debugging problems
+     * that may be associated with particular configurations.
+     * For example, CONFIG message might include the CPU type,
+     * the graphics depth, the GUI look-and-feel, etc.
+     * This level is initialized to <CODE>700</CODE>.
+     */
+    public static CONFIG = new LogLevel("CONFIG", 700);
+
+    /**
+     * FINE is a message level providing tracing information.
+     * <p>
+     * All of FINE, FINER, and FINEST are intended for relatively
+     * detailed tracing.  The exact meaning of the three levels will
+     * vary between subsystems, but in general, FINEST should be used
+     * for the most voluminous detailed output, FINER for somewhat
+     * less detailed output, and FINE for the  lowest volume (and
+     * most important) messages.
+     * <p>
+     * In general the FINE level should be used for information
+     * that will be broadly interesting to developers who do not have
+     * a specialized interest in the specific subsystem.
+     * <p>
+     * FINE messages might include things like minor (recoverable)
+     * failures.  Issues indicating potential performance problems
+     * are also worth logging as FINE.
+     * This level is initialized to <CODE>500</CODE>.
+     */
+    public static FINE = new LogLevel("FINE", 500);
+
+    /**
+     * FINER indicates a fairly detailed tracing message.
+     * By default logging calls for entering, returning, or throwing
+     * an exception are traced at this level.
+     * This level is initialized to <CODE>400</CODE>.
+     */
+    public static FINER = new LogLevel("FINER", 400);
+
+    /**
+     * FINEST indicates a highly detailed tracing message.
+     * This level is initialized to <CODE>300</CODE>.
+     */
+    public static FINEST = new LogLevel("FINEST", 300);
+
+    /**
+     * ALL indicates that all messages should be logged.
+     * This level is initialized to <CODE>Integer.MIN_VALUE</CODE>.
+     */
+    public static ALL = new LogLevel("ALL", Number.MIN_VALUE);
+
+    private name: string
+    private value: number = 0;
+
+    constructor(name: string, value: number) {
+        this.name = name;
+        this.value = value;
+    }
+
+    intValue(): number {
+        return this.value;
+    }
+
+    getName(): string { 
+        return this.name;
+    }
+}

package/src/main/ts/armyc2/c5isr/renderer/utilities/MODrawRules.ts

@@ -0,0 +1,219 @@
+/**
+ * Draw Rules for METEOROLOGICAL AND OCEANOGRAPHIC SYMBOLOGY
+ *
+ */
+export class MODrawRules {
+
+    /**
+     * Usually an entry in the MilStd that is just a category containing other symbols
+     * and not something that gets drawn itself.
+     */
+    public static readonly DONOTDRAW: number = 0;
+
+    /**
+     * Anchor Points: This graphic requires at least three anchor points to
+     * define the boundary of the area. Add as many points as necessary to
+     * accurately reflect the area's size and shape.
+     * Size/Shape: Scalable.
+     * Orientation: Not applicable.
+     */
+    public static readonly AREA1: number = 101;
+
+    /**
+     * Anchor Points: This graphic requires at least three anchor points to
+     * define the boundary of the area. Add as many points as necessary to
+     * accurately reflect the area's size and shape.
+     * Size/Shape: Determined by the anchor points.
+     * Orientation: Not applicable.
+     */
+    public static readonly AREA2: number = 102;
+
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is typically centered over the desired location.
+     */
+    public static readonly POINT1: number = 201;
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the geometric center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is centered over the anchor location.
+     */
+    public static readonly POINT2: number = 202;
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is oriented upright on the display and operator-centered over the desired location.
+     */
+    public static readonly POINT3: number = 203;
+
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is centered over the location of the reported wind.
+     */
+    public static readonly POINT4: number = 204;
+
+
+    /**
+     * Anchor Points: This graphic requires a minimum of two anchor points.
+     * The first point defines the location of the plot circle.
+     * Additional points define the wind shaft and the speed of the wind.
+     * Wind speed is depicted on the shaft using a combination of the shaft
+     * alone (1-2 knots), half barbs (5 knots), barbs (10 knots)
+     * and pennants (50 knots). Wind speeds 5 knots or greater are rounded
+     * to the nearest 5 knots. Missing wind speed is depicted by an "X" at
+     * the end of the wind shaft. Winds with missing direction are not displayed.
+     *
+     * Size/Shape: Not applicable.
+     *
+     * Orientation: The shaft of the graphic is oriented with reference to
+     * true north in the direction from which the wind is blowing to the
+     * nearest 10 degrees. The barbs and pennants lie back from the shaft at
+     * an angle of 120 degrees and are oriented to the left of the shaft in
+     * the Northern Hemisphere and to the right in the Southern Hemisphere.
+     * The graphic is operator-centered over the desired location.
+     */
+    public static readonly POINT5: number = 205;
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is centered over the location of the reported cloud cover.
+     */
+    public static readonly POINT6: number = 206;
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is centered over the location of the reported conditions.
+     */
+    public static readonly POINT7: number = 207;
+
+    /**
+     * Anchor Points: This graphic requires one anchor point. The center point
+     * defines the center of the graphic.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is centered over the position of the tropical system.
+     */
+    public static readonly POINT8: number = 208;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined
+     * to extend the line.
+     * Size/Shape: Scalable/Curve. The curvature of the line is operator defined.
+     * Orientation: The first and last anchor points determine the length of
+     * the line.
+     */
+    public static readonly LINE1: number = 301;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined to
+     * extend the line.
+     *
+     * Size/Shape: Scalable/Curve. The points are typically connected with a
+     * straight line consisting of a short line section and an alternating
+     * V shape. The curvature and amplitude of the waves of the line is
+     * operator defined.
+     *
+     * Orientation: The first and last anchor points determine the length of
+     * the line. The line should be drawn so the "V" shapes are facing in
+     * the direction of movement. The "V" shapes and short line segment will
+     * alternate along the line.
+     */
+    public static readonly LINE2: number = 302;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined to
+     * extend the line.
+     *
+     * Size/Shape: Scalable/Curve. The points are typically connected with a
+     * straight line consisting of a short line section and alternating two
+     * dots. The curvature and amplitude of the waves of the line is
+     * operator defined.
+     *
+     * Orientation: The first and last anchor points determine the length of the line. The two dots and the short line segment will alternate along the line.
+     */
+    public static readonly LINE3: number = 303;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined to
+     * extend the line.
+     *
+     * Size/Shape: Scalable/Curve. The points are typically connected with a
+     * curved/wavy line consisting of a short line and one dot. The curvature
+     * and amplitude of the waves of the line is operator defined.
+     *
+     * Orientation: The first and last anchor points determine the length of
+     * the line. The dot and the short line segment will alternate along
+     * the line.
+     */
+    public static readonly LINE4: number = 304;
+
+    /**
+     * Anchor Points: This graphic requires at least three anchor points to
+     * define the boundary of the area. Add as many points as necessary to
+     * accurately reflect the area's size and shape.
+     *
+     * Size/Shape: Determined by the anchor points.
+     *
+     * Orientation: The first and last anchor points determine the length of
+     * the line. The dual line segments will be parallel to slightly wider at
+     * the western end.
+     */
+    public static readonly LINE5: number = 305;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined to
+     * extend the line.
+     * Size/Shape: Scalable/Curve. The points are typically connected with a
+     * solid straight line with alternating slanted lines connected as depicted
+     * in the example to indicate convergence.
+     * Orientation: The first and last anchor points determine the length of
+     * the line. The alternating slanted lines will be evenly spaced along
+     * the line. Orientation is determined by the anchor points.
+     */
+    public static readonly LINE6: number = 306;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined to
+     * extend the line.
+     *
+     * Size/Shape: Scalable/Curve. The points are typically connected with a
+     * dashed straight or curved line. The curvature of the line is operator
+     * defined.
+     *
+     * Orientation: The first and last anchor points determine the length of
+     * the line. The red and green line segments will alternate along the line.
+     * Orientation is determined by the anchor points.
+     */
+    public static readonly LINE7: number = 307;
+
+    /**
+     * Anchor Points: This graphic requires at least two anchor points,
+     * points 1 and 2, to define the line. Additional points can be defined to
+     * extend the line.
+     * Size/Shape: Scalable.
+     * Orientation: The graphic is oriented upright on the display as shown in
+     * the example and operator-centered over the desired location.
+     */
+    public static readonly LINE8: number = 308;
+
+
+}