flyweight | A C11 library implementing the flyweight design pattern | Architecture library

Yes, destructure lists from the props object and, assuming lists is an array, map as normal JSX. Here I'm assuming the lists array contains element objects that have a value and label property to display from, this will need to be tweaked to fit your actual lists array element shape.

You can configure the master node to only be used when explicitly named. Just click the master node > go to configure and change Use this node as much as possible to Only build jobs with label expressions matching this node

Unordered containers will largely have irrelevant, non-repeatable hashes.

This is because hash(a,b,c) is not the same as hash(b,a,c) or hash(c, a, b) etc.

Since the ordering cannot be depended and only implicitly controlled, you will never know what it means to have "identical hash". The main rule of hashes for lookup is that equivalent values should hash to the same value, but since different sets {a,b,c} as an unordered container might hash to different values while being equivalent this would break the semantics.

Of course, you can make an ordered view of the set and then hash that, but it would appear to be prohibitively costly - a good reason to not provide it by default.

As to why forward_list is excluded, I'm not so sure. This looks like simple oversight.

your problem doesn't sound like the intented usage scenario for the flyweight pattern which is for a big number of objects (build with repeating attributes/child objects) to "outsource" the repeatingly needed attributes/child objects to a central memory structure and then when a certain main object from your collection of objects is used to rebuild it by referencing the "outsourced" objects. (check here enter link description here
In you example you would outsource publishDate and Language objects if they were objects.

What I understood you want to do is simply preventing the creation of a duplicate if there already is an instance of that same book registered. The "same book" is currently identified by three attributes (bookName, bookPublishingDate, bookLanguage).

You can do this with your approach only the key in the hashmap should be aggregated out of all relevant attributes of the book.

Like

String bookSignature = bookName+bookPublishingDate.toString()+bookLanguage;

The creation of the String can be done with a StringBuilder if you want to save memory.

In the example class diagram given by the Geeks for Geeks author

If I understand this correctly, the game creates one instance of Terrorist, one instance of CounterTerrorist, and n instances of Player created by the PlayerFactory.

The code reflects the diagram. Terrorist and CounterTerrorist implement the Player interface.

Each Player instance created by the PlayerFactory uses the information from the Terrorist or CounterTerrorist instance, depending on which side the player is on. Since there's a Player instance for each player (Usually 10 in CounterStrike, 5 on each side), there's no confusion as to which player is which.

The CounterStrike class manages the Map created by the PlayerFactory.

This simple real-world example minimizes the duplication that would occur if there were just n Player instances. Each Player instance would have to hold the information for both a terrorist and a counter-terrorist.

By creating one instance of Terrorist, one instance of CounterTerrorist, and sharing those instances with the Player instances, the total amount of storage for the game fields is reduced.

The game code is probably easier to debug and manage as well.

The Java code can be found on Geeks For Geeks.

The Flyweight design pattern is just a special application of caching. In a scenario where you cannot cache an entire object, because some of the object's state is unique, Flyweight reminds us that we may still cache part of the object, if we separate a part that is not unique and can be shared.

Since Flyweight is nothing more than partial caching, it provides generally the same benefits as caching, including reduction in time & space complexity. Therefore, the answer to your question is yes, instantiation costs (time resources) make for a valid application of the Flyweight pattern. Of course this is assuming you can't just cache entire objects, which is altogether simpler than caching parts of them.

What you implemented isn't the lightweight pattern. There is no such thing as Block_light, but rather Block would be a pure interface to an implementation provided by something like Block1 which looks like what your Block definition looks like.

E.g.:

I wouldn't want to do either of those and you can get around both by making the Base take a generic, like so:

but could not be implemented in the constructor itself?

No: new, by specification, always creates a new instance (or fails), so new Boolean(b) would always return a new instance of Boolean.

Boolean.valueOf returns a pre-existing instance. This is desirable, because there are only two possible values, so there is simply no point in creating more.