ObjectPool | destroying new objects | Game Engine library

On one hand it doesn't throw me either error or warning …

You should enable all warnings in your project settings; see: Why should I always enable compiler warnings? With warnings enabled, your code (or a version of it I pasted into my VS 2019 IDE) generates 5 warnings:

warning C4255: 'main': no function prototype given: converting '()' to '(void)'
warning C4189: 'customer_p': local variable is initialized but not referenced
warning C4028: formal parameter 2 different from declaration
warning C4267: '=': conversion from 'size_t' to 'int', possible loss of data
warning C4716: 'createCustomer': must return a value

Now, #1, #2 and #4 can be put aside (for now); the big issues are #3 and #5.

To address #3: You need to make the arguments in your function definition (in "customer.c") the same as in the prototype (in "customer_api.h"); presumably, as the numOrders member of your structure is an int, you should change the former to have an int second argument (this also addresses and removes warning #4):

To address #5: The createCustomer function must return what it is declared to return: a CustomerPtr object. The local variable, newCustomer_p, is the obvious candidate for this.

Here is a 'fixed' version of that function:

If you write T, then T needs to be some particular type operation (e.g., type T = ... or interface T { ... or class T ...). There's no way to write T where T is a generic type parameter. That would require so-called higher-kinded types, of the sort requested in microsoft/TypeScript#1213, and TypeScript has no direct support for that.

You could step back and try to think of exactly what you want to do, and if there's any way to represent it without needing higher kinded types. If all you want is for ObjectPool to have all property keys in P, and for each such key K, you want the property value to have an id property equal K in addition to some other properties specified by T, then you can separate out the id part in the definition so that T is just a regular type. For example:

It's pretty complicated, but I believe the cause of launch()/async() not executing is that their parent coroutineScope() already finished at this point in time. Notice "11" happens before "4", meaning that you invoked launch() after going out of coroutineScope(). Which makes sense, because inTransaction() starts asynchronous operation, so it returns immediately, without waiting for the inner code. To fix this, you just need to move cdf.await() inside coroutineScope().

Another thing that concerns me is that you await on completable that you created by yourself and not the one returned from inTransaction(). Note that it may be a totally different CompletableFuture and in that case you actually return before the operation completes.

Also, I'm not sure if this manual exception handling for completable is really necessary. async() already performs exception handling and wraps the result as CompleteableDeferred, then it is converted to CompletableFuture which also wraps exceptions. The only thing we have to do is to replace coroutineScope() with supervisorScope(). Otherwise, async() would automatically signal coroutineScope() to fail, so the exception handling would totally bypass inTransaction() function.

Try this code:

Just an idea for making Commons Pool offer a suspending borrow method. I didn't spend a lot of time reasoning this out, so I can't guarantee it totally makes sense. But my thinking is that since it already tries to unblock threads in the order they requested objects, it should be fine to have all the requests come in on the same thread and the coroutines will receive their objects in the same order they were requested. So, you can attach a single Thread Dispatcher to the single Pool. The downside is it ends up briefly suspending to swap threads even when the pool is not exhausted.

I think it's a good idea to make one more layer between ObjectPool and Monster classes that will manage what you want. It will complete Single responsibility principle of SOLID.

So both classes ObjectPool and Monster will not depend on each other and every class will be making their jobs.

Yes, you can set the destination image of an ImageReadParam object. However, there is a caveat: the BufferedImage must have a ColorModel and SampleModel that match the image being loaded.

I’m not sure about JPEG2000 images, but regular JPEGs are usually RGB images, so an image of TYPE_INT_RGB should suffice:

First, it seems you are clogging the event handling thread. So, what I'd do is decouple event handling from the actual processing:

( Untested! Just an outline!)

REMOVED FAULTY CODE

Then in serviceInstance1, I would have Publish enqueue the orders in a BlockingCollection, on which a dedicated Thread is waiting. That thread will do the actual send. So you'll marshall the orders to that thread regardless of what you chose to do in Processor and all will be decoupled and in-order.

You probably will want to set BlockOptions according to your requirements.

Mind that this is just a coarse outline, not a complete solution. You may also want to go from there and minimize string-operations etc.

Some more thoughts that came to me since yesterday in no particular order:

• May it be beneficial to ditch the first filter to filter out empty sets of JObjects later?
• Maybe it's worth trying to use System.Text.Json instead of Newtonsoft?
• Is there a more efficient way to get from xml to json? (I was thinking "XSLT" but really not sure)
  • convert xml to json using xslt
  • xml to json using xslt
• I'd recommend to rig up a Benchmark.Net with MemoryAnalyzer to document / proove your changes have positive effects.
• Don't forget to have a look into DataFlowBockOptions to tweak the pipeline's behavior.

• DataFlow
• Walkthrough: Creating a Dataflow Pipeline
• What's so wrong about using GC.Collect()?

here is the major problem: