simplicity | Simple template and workflow scripts | BPM library

fromCallable doesn't shield you from blocking computation inside the Callable, which your example demonstrates.

The primary mean of cancellation in Reactive Streams is the cancel() signal propagated from downstream via the Subscription.

Even with that, the fundamental requirement of avoiding blocking code inside reactive code still holds, because if the operators are simple enough (ie. synchronous), a blocking step could even prevent the propagation of the cancel() signal...

A way to adapt non-reactive code while still getting notified about cancellation is Mono.create: it exposes a MonoSink (via a Consumer) which can be used to push elements to downstream, and at the same time it has a onCancel handler.

You would need to rewrite your code to eg. check an AtomicBoolean on each iteration of the loop, and have that AtomicBoolean flipped in the sink's onCancel handler:

If your frontend and backend can be built and deployed seperately, than you can use rules:changes to check if a change happened and need:optional to only deploy the respective built libraries.

you are almost there.. you just need to use the same logic to join to the product master table. However, since you need the total of quantity, you need to group by the other columns you select (but not aggregate).

The query will be something like this :

I think I have some idea regarding it. What you can do is store the list like.

Instead of passing the idKey as a constructor parameter, I would suggest reflecting it as metadata of the class. This way, you could do something like

As you can see this is the same evaluation as your code but with optimized approach, FizzBuzz questions are to test on how to write an efficient algorithm. Just because the code is working it doesn't mean it shouldn't be optimized.

In here you can see I'm checking every interval and appending the string by words. If you use modulo(%) operator, then it uses more cpu clocks, I know it is nothing for current generation computers, but it's good practice with problems like this

It depends. You could try:

Can I try to read if it no data available?

Yep, and it's going to be case more often than not. Read() will do nothing until data is available, and only then put its passed tag into the completion queue. (see below for details)

Is it blocking call?

Nope. Read() and Write() return immediately. However, you can only have one of each in flight at any given moment. If you try to send a second one before the previous has completed, it (the second one) will fail.

What is the proper way to async reading?

Each time a Read() is done, start a new one. For that, you need to be able to tell when a Read() is done. This is where tags come in!

When you call Read(&msg, tag), or Write(request, tag),you are telling grpc to put tag in the completion queue associated with that responder once that operation has completed. grpc doesn't care what the tag is, it just hands it off.

So the general strategy you will want to go for is:

• As soon as you are ready to start receiving messages:
  • call responder->Read() once with some tag that you will recognize as a "read done".
• Whenever cq_.Next() gives you back that tag, and ok == true:
  • consume the message
  • Queue up a new responder->Read() with that same tag.

Obviously, you'll also want to do something similar for your calls to Write().

But since you still want to be able to lookup the handler instance from a given tag, you'll need a way to pack a reference to the handler as well as information about which operation is being finished in a single tag.

Lookup the handler instance from a given tag? Why?

The true raison d'être of completion queues is unfortunately not evident from the examples. They allow multiple asynchronous rpcs to share the same thread. Unless your application only ever makes a single rpc call, the handling thread should not be associated with a specific responder. Instead, that thread should be a general-purpose worker that dispatches events to the correct handler based on the content of the tag.

The official examples tend to do that by using pointer to the handler object as the tag. That works when there's a specific sequence of events to expect since you can easily predict what a handler is reacting to. You often can't do that with async bidirectional streams, since any given completion event could be a Read() or a Write() finishing.

Here's a general outline of what I personally consider to be a clean way to go about all that:

As @jnpdx pointed out - using @Published with a class (especially a singleton that never changes) is probably not going to yield any useful results

@Published behaves like CurrentValueSubject and it will trigger an update only in case there are changes in the value it is storing/observing under the hood. Since it is storing a reference to the Contacts.shared instance, it won't provide/trigger any updates for the authorization state changes.

Now to your question - Given that ModelData().contacts.authorization calls a getter function, not a property, how can I inform the SwiftUI view when I know it's changed

As long as you are directly accessing a value out of the getter ModelData().contacts.authorization, it's just a value of Contacts.Authorization type that does NOT provide any observability.

So even if the value changes over time (from .notDetermined => .authorized), there is no storage (reference point) against which we can compare whether it has changed since last time or not.

We HAVE TO define a storage that can compare the old/new values and trigger updates as needed. This can achieved be by marking authorization as @Published like following -