Search for a command to run...
I am a developer from India with a good eye for frontend logic and design. I am also well acquainted with the backend and business logic so that's add to my ability to create a good frontend while making it easily integratable with backend.
No comments yet. Be the first to comment.
Understanding and Reading the MNIST Dataset
In the digital age, where data breaches are as common as coffee spills, one cryptographic algorithm stands out for its robustness in securing our passwords: bcrypt. Let's dive into the world of bcrypt hashing, uncovering its mechanics, the role of sa...
In our daily used language, we use Grammar, similarly, in computer language, we have a set of rules called grammar on which a language is defined. In this article, we will look into what those Grammars are and how we define and use them. Exploring th...
Introduction In the vast landscape of computer science, languages are not just confined to human communication; they also extend into the realm of formal languages, classified into regular and non-regular categories. Understanding these languages is ...
Hello Guys, welcome back to my blog. Today we will be creating our small server and React app to learn about Server-Sent Events and how to handle them in a React App. But before we even start building anything let's learn about Server-Side Events (SS...
On this page
Recently, in my organization, we came across a need to build an index of files we are using for our in-browser filesystem, where we have the id's of the file/folder which is how frontend understands and a path associated with it in the in-browser file system.
After a couple of ideas, I thought of creating a map with all the ids mapped to their current path, which was a good idea. But after thinking it harder I found that the update path ( which is basically update Name) would be harder and can't be achieved easily by using one map only, as if we update a folder we need to update all the child component's path also. To do so I also needed a reference to all the paths and a way to easily access them.
I thought of building a bidirectional Map where one map's key are id and the other map's key is the path. Well, this was a very good solution and optimal in my case. Below is a mental picture of it.
After building a basic mental idea about this, I needed to build APIs for this datastructure which can be used and can be easily extended. I was pretty sure we would need operations like add(), get() , update(), delete() . But apart from these, we can also have, getall() other operations depending upon the need.
below is the code of how the finished structure looks in Typescript.
/**
* @template K - The type of keys.
* @template V - The type of values.
*
* @class
* @classdesc A simple bidirectional map for mapping between keys and values.
* Provides methods to add mappings and retrieve values by key or value.
*
* @example
* // Example usage:
* const bidirectionalMap = new BidirectionalMap<string, number>();
* bidirectionalMap.addMapping('apple', 1);
* bidirectionalMap.addMapping('orange', 2);
*
* // Using key to get value
* console.log(bidirectionalMap.getValue('apple')); // Output: 1
*
* // Using value to get key
* console.log(bidirectionalMap.getValue(2)); // Output: orange
*/
class BidirectionalMap<K, V> {
/**
* @private
* @type {Map<K, V>} - The forward mapping from keys to values.
*/
private forwardMap: Map<K, V>;
/**
* @private
* @type {Map<V, K>} - The reverse mapping from values to keys.
*/
private reverseMap: Map<V, K>;
/**
* Creates a new instance of BidirectionalMap.
* @constructor
*/
constructor() {
this.forwardMap = new Map<K, V>(); // used to map key ===> path
this.reverseMap = new Map<V, K>(); // used to map path ====> key
}
/**
* Adds a bidirectional mapping between a key and a value.
*
* @param {K} key - The key to be mapped.
* @param {V} value - The value to be mapped.
* @returns {void}
* @memberof BidirectionalMap
*/
addMapping(key: K, value: V): void {
this.forwardMap.set(key, value);
this.reverseMap.set(value, key);
}
/**
* Retrieves the value associated with the provided key or value.
*
* @param {K | V} keyOrValue - The key or value for which to retrieve the associated value or key.
* @returns {V | K | undefined} The associated value or key, or undefined if not found.
* @memberof BidirectionalMap
*/
getValue(keyOrValue: K | V): V | K | undefined {
if (this.forwardMap.has(keyOrValue as K)) {
return this.forwardMap.get(keyOrValue as K);
} else if (this.reverseMap.has(keyOrValue as V)) {
return this.reverseMap.get(keyOrValue as V);
} else {
return undefined;
}
}
getAllKeysFromForwardMap() {
return this.forwardMap.keys();
}
getAllKeysFromReverseMap() {
return this.reverseMap.keys();
}
getAllValuesFromForwardMap() {
return this.forwardMap.values();
}
getAllValuesFromReverseMap() {
return this.reverseMap.values();
}
getValueFromForwardMap(key: K) {
return this.forwardMap.get(key);
}
getValueFromReverseMap(key: V) {
return this.reverseMap.get(key);
}
// TODO: This should update the the values in the both things
updateValue(key: K, value: V) {
// Update the value of key in forward Map and backward Map
this.addMapping(key, value);
}
getMapping() {
return {
forwardMap: this.forwardMap,
backwardMap: this.reverseMap,
};
}
}
the only thing that is missing is the delete() method, which you guys can create on your own.
Once this is gone the usage of this looks something like below.
Example Usage:
@example
// Example usage:
const bidirectionalMap = new BidirectionalMap<string, number>();
bidirectionalMap.addMapping('apple', 1);
bidirectionalMap.addMapping('orange', 2);
// Using key to get value
console.log(bidirectionalMap.getValue('apple')); // Output: 1
// Using value to get key
console.log(bidirectionalMap.getValue(2)); // Output: orange
Thank you for reading so far. If you learned something new and liked the article please follow me and subscribe to my email newsletter.